Java Spring的IoC和AOP的知识点速记

Spring简介

Spring解决的最核心的问题就是把对象之间的依赖关系转为用配置文件来管理，这个是通过Spring的依赖注入机制实现的。

Spring Bean装配

1. IOC的概念以及在Spring容器中如何进行IOC的操作。

IOC：Inversion of Control，控制反转。在Java开发中，IOC意味着将你设计好的类交给系统去控制，而不是在你的类内部控制，这称为控制反转，就是被调用类的实例由原先的调用类控制创建、销毁现在转变成由Spring的容器管理。

2. Spring容器是如何管理Bean的生命周期的（如Bean的初始化方法，Bean的销毁方法）

创建：<bean name=”” class=”” 额外属性>

初始化：配置init­-method/实现接口InitializingBean

调用：context.getBean()，进行方法的调用

销毁：配置destroy-­method/实现DisposableBean接口

3. DI的概念以及在Spring框架注入有几种方式。使用构造注入对象，必须要注意什么问题？

注入方式：

构造注入[构造方法注入]

属性注入[属性的SET/GET]

方法注入[工厂注入]

<!-- 构造函数注入 -->
<bean id="user1" class="com.spring.test.model.User">
    <constructor-arg index="0" type="String" value="Lu"></constructor-arg>
    <constructor-arg index="1" type="String" value="123456"></constructor-arg>
</bean>
 
<!-- 属性注入 -->
<bean id="user2" class="com.spring.test.model.User">
    <property name="username" value="Luxx"></property>
    <property name="password" value="56789"></property>
</bean>
 
<!-- 工厂注入 -->
<bean id="userFactory" class="com.spring.test.factory.UserFactory"/>
<bean id="user3" factory-bean="userFactory" factory-method="createUser"></bean>
 
<!-- 静态工厂注入 -->
<bean id="user4" class="com.spring.test.factory.UserFactoryStatic" factory-method="createUser"></bean>

使用构造函数依赖注入时，Spring保证所有一个对象所有依赖的对象先实例化后，才实例化这个对象。使用set方法依赖注入时，Spring首先实例化对象，然后才实例化所有依赖的对象。

4. 使用DI注入时，Property代表什么意思，如果property引用的是其他Bean的话，如何注入，如果引用是字符串的话，如何设置。

使用DI注入时，Property代表注入类的属性，如果应用其他的bean用ref属性来表明被引用bean的名称，如果是引用字符串的话，用value属性。如：

<property name=”userDao” ref=”被引用bean的名称” />
<property name=”username” value = “字符串”/>

5. Bean的作用域

所有Spring Bean的默认都是单例，即scope=”singleton”

几种作用域：

singleton：在每一个Spring容器中，一个Bean定义只有一个对象实例。

prototype：Bean的定义可以被实例化任意次（每次调用都创建一个实例）。

request：在一次Http 请求中，每个Bean定义对应一个实例。该作用域仅在基于Web的Spring上下文（如Spring MVC）中才有效。

Session：在一个Http Session中，每个Bean定义对应一个实例。该作用域仅在基于Web的Spring上下文（如Spring MVC）中才有效。

Global-session：在一个全局Http Session中，每个Bean定义对应一个实例。该作用域仅在Portlet上下文中才有效。

6. DI自动装配（autowiring）

Spring中提供了自动装配依赖对象的机制，但是在实际应用中并不推荐使用自动装配，因为自动装配会产生未知情况，开发人员无法预见最终的装配结果。

自动装配是在配置文件中实现的，如下：

<bean id="***" class="***" autowire="byName">

只需要配置一个@Autowired属性即可完成自动装配，不用再配置文件中写<property>，但是在类中还是要生成依赖对象的setter方法。

Autowire的属性值有如下几个：

1）byName 按名称装配，可以根据属性的名称（或者ID）在容器中查询与该属性名称（或者ID）相同的bean，如果没有找到，则属性值为null；

2）byType 按类型装配，可以根据属性类型，在容器中寻找该类型匹配的bean，如有多个，则会抛出异常，如果没有找到，则属性值为null；如果有多个，使用bean的primary属性，注意：这个默认就是true，需要把非候选的bean的primary的属性设置为false。排除某些bean，设置某些bean的autowire-candidate属性为false。

3）constructor 与byType方式相似，不同之处在与它应用于构造器参数，如果在容器中没有找到与构造器参数类型一致的bean，那么将抛出异常；

4）autodetect 通过bean类的自省机制(introspection)来决定是使用constructor还是byType的方式进行自动装配。首先尝试使用constructor 进行自动装配。如果失败，再尝试使用byType的方式。

可选的自动装配：默认情况下，@Autowired具有强契约特性，其所标注的属性或参数必须是可装配的，如果没有，则自动装配失败（抛出NoSuchBeanDefinitionException）。属性不一定要装配，null值也是可以接受的，使用@Autowired(required=false)来配置是可选的。

限定歧义性的依赖：使用@Qualifier(“bean id”)，通过制定Bean的ID把选择范围缩小到只剩下一个Bean。

注意：显式的指定依赖，比如property和constructor-arg元素，总会覆盖自动装配。自动装配的行为可以和依赖检查结合使用，依赖检查会在自动装配完成后发生。

7. DI自动检测（autodiscovery）

配置Spring自动检测Bean的定义和自动装配Bean：

<context:component-scan base-package="com.spring.test"/>

默认情况下，<context:component-scan>查找使用构造型注解所标注的类，这些注解如下：

@Component 通用的构造型注解，标识该类为Spring组件。

@Controller 标识该类为Spring MVC controller。

@Repository 标识该类为数据仓库，一般作为DAO层的注解。

@Service 标识该类为服务，一般作为服务层的注解。

使用@Component标注的任意自定义注解。

Spring AOP

AOP的概念以及使用AOP机制有什么好处。

AOP的概念是Aspect Oriented Programming面向切面编程。本质上就是代理模式。

好处：AOP将程序分解成各个方面或者说关注点，这使得可以模块化，相当横向上分切了。它可以解决OOP和过程化方法不能够很好解决的横切（cross-cutting）问题，如：事务、安全、日志等横切关注。

Spring+AspectJ 实现AOP的2种方式：

1） 使用注解（@AspectJ）实现AOP：

@Aspect
@Component
public class LogAspect {
    @Before("execution(public * com.spring.test.service.*.*(..))")
    public void beforeService(){
        System.out.println("Before ...");
    }
 
    @After("execution(public * com.spring.test.service.*.*(..))")
    public void afterService(){
        System.out.println("After ...");
    }
 
    @AfterReturning("execution(public * com.spring.test.service.UserService.save(com.spring.test.model.User)) and args(user)")
    public void logAfterReturn(User user){
        System.out.println("After return..."+user);
    }
}

开启注解扫描：

xmlns:aop=http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
 
<context:component-scan base-package="com.spring.test"/>
<aop:aspectj-autoproxy proxy-target-class="true"/>

注意的是 proxy-target-class="true" 属性，它的默认值是 false，默认只能代理接口（使用 JDK 动态代理），当为 true 时，才能代理目标类（使用 CGLib 动态代理）。

2）另一种XML配置方式：

public class LogAspect {
    public void beforeService(){
        System.out.println("Before ...");
    }
 
    public void afterService(){
        System.out.println("After ...");
    }
 
    public void logAfterReturn(User user){
        System.out.println("After return..."+user);
    }
}

配置：

<bean id="logAspect" class="com.spring.test.aop.LogAspect" />
<aop:config>
<aop:aspectref="logAspect">
    <aop:pointcut id="serviceAction" expression="execution(public * com.spring.test.service.*.*(..))"/>
    <aop:beforepointcut-ref="serviceAction" method="beforeService"/>
    <aop:afterpointcut-ref="serviceAction" method="afterService"/>
 
    <aop:pointcutid="serviceReturnAction"
    expression="execution(public * com.spring.test.service.UserService.save(com.spring.test.model.User)) and args(user)"/>
    <aop:after-returningpointcut-ref="serviceReturnAction" method="logAfterReturn" arg-names="user"/>
</aop:aspect>
</aop:config>

使用 <aop:config> 元素来进行 AOP 配置，在其子元素中配置切面，包括增强类型、目标方法、切点等信息。

参考：

http://docs.spring.io/spring/docs/current/spring-framework-reference/html/index.html

http://oss.org.cn/ossdocs/framework/spring/zh-cn/beans.html