spring原理及工作方式

一、 IoC(Inversion of control): 控制反转 

1、IoC： 
概念：控制权由对象本身转向容器；由容器根据配置文件去创建实例并创建各个实例之间的依赖关系 

核心：bean工厂；在Spring中，bean工厂创建的各个实例称作bean 

IOC（Inverse of Control）可翻译为“控制反转”，但大多数人都习惯将它称为“依赖注入”。在Spring中，通过IOC可以将实现类 、参数信息等配置在其对应的配置文件中 ，那么当需要更改实现类或参数信息时，只需要修改配置文件即可，这种方法在上例的基础上更进一步的降低了类与类之间的耦合。我们还可以对某对象所需要的其它对象进行注入 ，这种注入都是在配置文件中做的，Spring的IOC的实现原理利用的就是Java的反射机制，Spring还充当了工厂的角色，我们不需要自己建立工厂类 。Spring的工厂类会帮我们完成配置文件的读取、利用反射机制注入对象等工作，我们可以通过bean的名称获取对应的对象。

工作方式:

（1）属性注入

        属性注入的语法如下：

        <bean id="被注入的类的beanId" class="包名.类名" />

        <bean id="beanId" class="包名.类名">
              <property name="被注入的bean的名字" ref="被注入的类的beanId"></property>
         </bean>

        在本例中，属性注入的具体配置如下：

?

1 2 3 4

<bean id= "userDao" class = "com.uni2uni.spring.dao.impl.UserDao" />   <bean id= "userService" class = "com.uni2uni.spring.service.impl.UserService" >    <property name= "userDao" ref= "userDao" ></property>   </bean>

        因为UserService依赖与UserDao，因此需要在userService中创建相应的getter和setter方法。UserService中的属性定义如下所示：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

package com.uni2uni.spring.service.impl; import com.uni2uni.spring.dao.IUserDao; import com.uni2uni.spring.model.User; import com.uni2uni.spring.service.IUserService;    public class UserService  implements IUserService{      private IUserDao userDao;   public IUserDao getUserDao() {    return userDao;   }   public void setUserDao(IUserDao userDao) {    this .userDao = userDao;   }    ......省略部分代码 }

（2）构造方法注入

        构造方法注入的语法如下：

        <bean id="被注入的类的beanId" class="包名.类名" />

        <bean id="beanId" class="包名.类名">
              <constructor-arg ref="被注入的类的beanId" />         

        </bean>

        本例中，构造方法注入的具体配置如下：

?

1 2 3 4

<bean id= "userService" class = "com.uni2uni.spring.service.impl.UserService" />   <bean id= "userAction" class = "com.uni2uni.spring.action.UserAction" >    <constructor-arg ref= "userService" />   </bean>

        由于本例中使用构造方法注入，因此需要在UserAction中编写UserService的构造方法，UserAction中的构造方法定义如下所示：

?

1 2 3 4 5 6 7 8 9 10 11 12 13

package com.uni2uni.spring.action; import com.uni2uni.spring.model.User; import com.uni2uni.spring.service.IUserService;    public class UserAction {   private IUserService userService;     public UserAction(IUserService userService) {    super ();    this .userService = userService;   }      ......省略部分代码 }

（3）自动注入

        自动注入语法如下所示：

        <bean id="beanId" class="包名.类名" autowire="参数值" />

        autowire的参数值可选有：“default”、“byName”、“byType”、“constructor”、“no”。

        default：根据bean的自省机制决定采用byType还是constructor进行自动装配，如果Bean提供了默认的构造函数，则采用byType，否则采用constructor。

        byName：通过属性名自动注入。

        byType：通过属性类型自动注入。

        constructor：与byType相同，但作用于构造器。

        no：不自动注入。

（4）Annotation注入

        Spring在3.0以后，提供了基于Annotation（注解）的注入。

        这种方式是在类名上使用注解的方式进行注入。

        Annotation注入的步骤如下：

        a.配置spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:aop="http://www.springframework.org/schema/aop"
     xmlns:context="http://www.springframework.org/schema/context"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context-3.0.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
   <!--第一步.、打开Spring的Annotation支持 -->
   <context:annotation-config/>
   <!-- 第二步、设定Spring 去哪些包中找Annotation -->
   <context:component-scan base-package="com.uni2uni.spring"/>
   <!-- 第三步、打开基于Annotation的AOP -->
   <aop:aspectj-autoproxy/>
</beans>

        b.在类上面添加注解

具体方法是：在类上面加@Component("beanId")，在setter方法上加@Resource即可。如果需要指定scope属性，则添加@Scope("singleton|prototype|...")即可。如下所示：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

package com.uni2uni.spring.action; import javax.annotation.Resource; import org.springframework.stereotype.Component; import com.uni2uni.spring.model.User; import com.uni2uni.spring.service.IUserService; @Component ( "userAction" ) @Scope ( "prototype" ) public class UserAction {   private User user;   private IUserService userService;   private int id;   public UserAction(IUserService userService) {    super ();    this .userService = userService;   }   public User getUser() {    return user;   }      @Resource   public void setUser(User user) {    this .user = user;   }   public IUserService getUserService() {    return userService;   }   @Resource   public void setUserService(IUserService userService) {    this .userService = userService;   }   public int getId() {    return id;   }   public void setId( int id) {    this .id = id;   }   public void add(){    userService.add(user);   }      public void delete(){    userService.delete(id);   }      public void Get(){    userService.Get(id);   } }

        注意：在新的Spring3的标准中，已经不推荐使用@Component的方式来完成bean的创建。新的标准提供了更多的Annotation来替代@Component。例如：

        @Repository：一般用于Dao的注入；

        @Service：一般用于Service层的注入；

        @Controller：一般用于Action层的注入。

二、AOP(Aspect-Oriented Programming): 面向方面编程 

1、 代理的两种方式： 
静态代理： 
 针对每个具体类分别编写代理类； 
 针对一个接口编写一个代理类； 
动态代理： 
针对一个方面编写一个InvocationHandler，然后借用JDK反射包中的Proxy类为各种接口动态生成相应的代理类 

2、 AOP的主要原理：动态代理