浅谈SSH框架中spring的原理
在ssh项目中，是有明确分工的，spring的作用就相当于将struts和hibernate连接起来，是将两个没有关系的框架的特性，方法，action都放在spring的配置文件中使他们建立关系。取他门各自所长。而这些做法他们自己不知道，他们是听命于spring调度的，他的的任务只是做好自己的事情。
这样做的好处就是任务结构分明，struts只管理显示与做什么，hibernate只关心怎么做，而spring就相当于领导，所以一切的类都要交给spring的工厂创建，这是一种良好的开发模式，体现了一种编程思想，最大的好处就是结构分明，便于维护，一旦项目出现问题，只修改spring文件，而不在你复杂的程序中去发现是谁在调用谁。
简而言之，ssh框架总体是为了解耦合使用的，struts管理表示层，spring管理业务逻辑层，hibernate管理持久化层，3个框架互相不关联，spring调用hibernate、struts调用spring来做方法调用，好处在于spring面向接口的设计，只要你的接口不变，impl变动在配置文件中配置就好了，这样在工程实施后，可以实现软编码，在异地调用用的配置文件直接修改配置文件调用已经写好的类，来增加功能。
下面结合实例理解解容器，di，ioc，耦合，解耦等spring所涉及的概念，同时了解spring的最基本也是最核心的使用方法。
1．spring容器
spring容器负责对象的实例化，对象生命周期的管理，被spring管理的对象称之为bean。
例如有soldier类需要交由spring容器管理，我们先编写类
package com.hb;
public class soldier {
private string name;
public string getname() {
return name;
}
public void setname(string name) {
this.name = name;
}
}
在spring配置文件中添加如下配置
<</span>bean id="s1" class="com.hb.soldier"></</span>bean>
初始化spring容器
public class test {
public static void main(string[] args) {
applicationcontext context = new
classpathxmlapplicationcontext("applicationcontext.xml");
}
}
从spring容器中取得对象实例
soldier s1 = (soldier) context.getbean("s1");
spring默认使用单例的方式创建对象。可以通过修改的配置改变成其它创建方式。这个属性为scope，称之为作用域或生命周期，它的值为singleton（单例，默认值），prototype（每次产生一个新的实例）等。
<</span>bean id="s1" class="com.hb.soldier" scope="prototype"></</span>bean>
2． 注入方式有setter注入，构造注入方式，接口注入（不需掌握）。建议多使用setter注入方式。
setter注入：
soldier类中有一个属性name，如何在创建soldier的时候使name的值变为”ranbo”?
配置如下：
<</span>bean id="s1" class="com.hb.soldier"> <</span>property name="name" value="ranbo"/> </</span>bean>
这样创建的soldier对象的name属性就有值了，测试代码：
public static void main(string[] args) {
applicationcontext context = new classpathxmlapplicationcontext("applicationcontext.xml");
soldier s1 = (soldier) context.getbean("s1");
system.out.println(s1.getname());
}
构造注入：
我们先修改下soldier类，给它添加一个构造方法：
package com.hb;
public class soldier {
private string name;
public soldier(string name) {
this.name = name;
}
public string getname() {
return name;
}
}
配置如下：
<</span>bean id="s1" class="com.hb.soldier"> <</span>constructor-arg value="ranbo"></</span>constructor-arg> </</span>bean>
测试结果同上。
3． 依赖
当a对象使用了b对象的方法，a对b产生依赖，称之为a依赖b。下面的例子中soldier类依赖handgun类。
package com.hb;
public class soldier {
public void fight(){
handgun handgun = new handgun();
handgun.killenemy();
}
}
package com.hb;
public class handgun {
public void killenemy(){
system.out.println("手枪杀敌");
}
}
当handgun发生变化时，必然导致soldier必须做相应修改，同时，当soldier需要使用othergun时也必须重新编写代码，导致代码重用度不高。
当对象之间的依赖关系很强时（耦合），会使程序代码死板，不利于后期的维护和扩展。降低对象之间的依赖关系称之为解耦。spring能够很好的解决这一问题。
4． 控制反转（inversion of control,简称ioc）和依赖注入(dependence inject简称di)
我们运用spring的setter注入方式解决handgun和soldier的耦合问题。修改soldier的代码，将handgun定义为soldier的属性并提供setter方法：
package com.hb;
public class soldier {
private handgun handgun;
public void sethandgun(handgun handgun) {
this.handgun = handgun;
}
public void fight(){
handgun.killenemy();
}
}
配置如下
<</span>bean id="s1" class="com.hb.soldier"> <</span>property name="handgun"> <</span>ref bean="handgun"></</span>ref> </</span>property> </</span>bean> <</span>bean id="handgun" class="com.hb.handgun"></</span>bean>
到这里，我们已经降低了handgun和soldier的部分依赖关系，至少在soldier中不用再自己去实例化handgun了。然而并没有彻底解决问题，soldier中仍然可以看到handgun类，因此我们使用接口进一步改进代码:
package com.hb;
public interface weapon {
void killenemy();
}
package com.hb;
public class handgun implements weapon{
public void killenemy(){
system.out.println("手枪杀敌");
}
}
package com.hb;
public class soldier {
private weapon weapon;
public void setweapon(weapon weapon) {
this.weapon = weapon;
}
public void fight(){
weapon.killenemy();
}
}
配置如下
<</span>bean id="s1" class="com.hb.soldier"> <</span>property name="weapon"> <</span>ref bean="handgun"></</span>ref> </</span>property> </</span>bean> <</span>bean id="handgun" class="com.hb.handgun"></</span>bean>
测试：
applicationcontext context = new
classpathxmlapplicationcontext("applicationcontext.xml");
soldier s1 = (soldier) context.getbean("s1");
s1.fight();
至此，我们使用spring很好的解决了handgun和soldier的耦合问题。soldier类中再也看不到handgun的踪影了，soldier只依赖于接口，而最终soldier还是使用了handgun，这是为什么呢？spring在这里管理了单个的对象，也管理了对象之间即soldier和handgun的依赖关系。原本是由soldier控制handgun的实例化的，转变为由spring容器来控制，这里发生了控制权的转移，这就是控制反转（inversion of control,简称ioc）。当soldier需要handgun时，spring会自动将handgun对象注入给soldier，这就是依赖注入了。
以上这篇浅谈ssh框架中spring的原理就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持。