Spring 相关知识复习

---

Bean的简单概念

Bean主要指可重复使用的组件，使用Bean中的功能需要通过其实例来调用。其实例的创建主要依赖Bean容器(container)。因此Bean的书写需要遵循相关规范，以满足容器对java类文件的分析要求。因此，可以简单理解Bean是按照特定规则书写的java类。规则要求为：

• 这个Java类必须具有一个无参的构造函数
• 属性必须私有化。
• 私有化的属性必须通过public类型的方法暴露给其它程序，并且方法的命名也必须遵守一定的命名规范。
• 这个类应是可序列化的。（比如可以实现Serializable接口，用于实现bean的持久性）

Spring bean

Spring中的bean只需提供为其属性设置值的setter方法即可，同时又spring管理其生命周期，并且通过配置文件等设置spring自动实例化。

Spring 关键技术

1. IoC控制反转

控制反转(Inversion of Control)是为了满足**依赖倒置(Dependency Injection)**的一种设计思想。将原本由高层依赖底层的依赖关系倒置过来。将底层注入到高层当中。反转关系和注入过程通过控制反转容器来实现。
传统关系中对象主动通过new去创建所需对象。控制反转则需先创建好对象之后由容器将所需对象注入。
所以控制反转主要是将对象的创建和获取分割到外部由容器提供。

2. 依赖注入

将类之间的依赖关系反转过后，创建被调用者的过程不再由调用者完成，而是交给相应的容器来创建相应的容器，之后再注入给调用者。使用依赖注入可以实现代码的松耦合。
- 依赖注入的方式
1. 使用set方法注入：

<bean id="className" class="类的全限定名">
	<!--set方法注入属性
	    name属性值：类中定义的属性名称
	    value属性值：设置具体的值
	-->
    <property name="name" value="zs"></property>
</bean>

2. 使用有参构造方法注入：

public class Person {
    private String name;
    public void setName(String name) {
        this.name = name;
    }
}

对于以上构造方法的注入方式为：

<bean id="user" class="cn.wang.ioc.User">
        <!--构造方法注入属性-->
        <constructor-arg name="pname" value="Tony"></constructor-arg>
</bean>

3. 注解注入：

常用的注解有@Component：可以用于注册所有bean；@Repository：主要用于注册dao层的bean；@Controller：主要用于注册控制层的bean；@Service：主要用于注册服务层的bean；@Autowired

3.AOP(面向切面编程)

• AOP的基本概念
  • Joinpoint(连接点)：类里面可以被增强的方法，这些方法称为连接点
  • Pointcut(切入点)：所谓切入点是指我们要对哪些Joinpoint进行拦截的定义
  • Advice(通知/增强)：所谓通知是指拦截到Joinpoint之后所要做的事情就是通知。通知分为前置通知，后置通知，异常通知，最终通知，环绕通知（方法之前和方法之后）
  • Aspect(切面)：把增强应用到具体方法上面，过程成为切面。
  • Target(目标对象)：代理的目标对象（要增强的类）
  • Weaving(织入)：是把增强应用到目标的过程，把advice应用到target的过程
  • Proxy(代理)：一个类被 AOP 织入增强后，就产生一个结果代理类

Spring中的AOP操作主要通过AspeJ来实现。使用xml和注解两种方式配置。使用时需导入相关jar包，同时spring的xml配置文件中的schema需要引入aop约束

• 代理设计模式

Spring的通过动态代理设计模式织入增强代码。开发AOP程序。

• 1.静态代理设计模式
  第一步创建被代理类接口

/**
 * 代理接口
 */
interface Interface{
    public String doSomething();
    public void somethingElse(String arg);
}

创建被代理类，继承代理接口

/**
 * 被代理类
 */
class RealObject implements Interface{
    public String doSomething(){
        System.out.println("[OUTPUT] do something");
        return "res";
    }

    public void somethingElse(String arg){
        System.out.println("[OUTPUT] something else "+arg);
    }
}

创建代理类，同样继承代理接口

/**
 * 代理类，对被代理类进行增强
 */
class SimpleProxy implements Interface{
    private Interface interObj;
    public SimpleProxy(RealObject obj){
        this.interObj = obj;
    }

    public String doSomething(){
        System.out.println("[OUTPUT] In Proxy Class");
        interObj.doSomething();
        return "proxy res";
    }

    public void somethingElse(String arg){
        System.out.println("[OUTPUT] In Proxy Class");
        interObj.somethingElse(arg);
    }
//测试类
class SimpleProxyTest{
    public static void excute(Interface interObj){
        interObj.doSomething();
        interObj.somethingElse("[param]");
    }
    public static void main(String[] args){
        excute(new SimpleProxy(new RealObject()));
    }
}
}

静态代理模式，将被代理类通过代理类构造函数传入代理类，并对其进行增强。

• 2.JDK动态代理
  代码中可以看到，对需要被增强的方法，代理类都需编写相应代码。代理类与被代理类关系还是相对紧密，所以引入了动态代理的模式。JDK动态代理主要依赖java.lang.reflect.Proxy类进行具体实现。首先同样需要上例中的代理接口和被代理对象
  其次，创建动态代理句柄DynamicProxyHandler并且需实现InvocationHandler接口并重写其中的invoke()方法。

/**
 * 动态代理句柄类
 */
class DynamicProxy implements InvocationHandler{
    private Object interObj;
    public DynamicProxy(Object obj){
        this.interObj = obj;
    }

    public Object invoke(Object proxy, Method method, Object[] args)throws Throwable{
        System.out.println("[OUTPUT] before invoke");
        Object res = method.invoke(interObj, args);
        System.out.println("[OUTPUT] after invoke");
        return res;
    }
}

这里的invoke()方法即为对被代理类中的相应方法需要做的增强。其中的method.invoke()方法即通过反射以args为参数调用被代理类的相应方法。

/**
 * 动态代理测试
 */
class SimpleDynamicProxy{
    public static void main(String[] args) {
        //System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
        Interface proxyClass = (Interface)Proxy.newProxyInstance(
            Interface.class.getClassLoader(), 
            new Class[]{ Interface.class}, 
            new DynamicProxy(new RealObject()));
        System.out.println(proxyClass.doSomething());
        proxyClass.somethingElse("in main");
         
    }
}

通过Proxy中的静态方法newProxyInstance()方法反射的创建代理类实例。由于newProxyInstance()方法返回值为Object类型所以需要转成接口类型。之后就可以继续调用。关于newProxyInstance的具体过程，会在另一篇文章里分享，在这里就不多展开描述了。

由以上可以，JDK动态代理需存在被代理类和其接口类，通过JDK中java.lang.reflect包中的内容来动态创建了代理类实例来实现的。我个人理解将其理解为，其实动态代理和静态代理的实质是一样的。只不过创建代理类的过程交由JDK通过反射的方式实现而不是我们自己编写。

• 3.CGLib动态代理。
  cglib动态代理的过程我没有实际写过，简单分享一下看到的概念。cglib可以在运行期扩展Java类与实现Java接口，通俗说cglib可以在运行时动态生成字节码。其过程是：cglib继承被代理的类，重写方法，织入通知，动态生成字节码并运行，因为是继承所以final类是没有办法动态代理的。因此，与JDK动态代理不同，cglib继承被代理类，因此便不需要被代理类接口的存在。提供了又一种方便。

4.Spring bean的生命周期

Spring bean的生命周期相较于java bean复杂很多。下图展示了spring bean从装载到应用上下文到销毁的一个生命周期

1. Spring 对 Bean 进行实例化：相当于程序中的new Xx()
2. Spring 将值和 Bean 的引用注入进 Bean 对应的属性中；
3. 如果Bean实现了 BeanNameAware 接口，Spring 将 Bean 的 ID 传递给setBeanName()方法。实现BeanNameAware清主要是为了通过Bean的引用来获得Bean的ID，一般业务中是很少有在Bean的ID的
4. 如果Bean实现了BeanFactoryAware接口，Spring将调用setBeanDactory(BeanFactory bf)方法并把BeanFactory容器实例作为参数传入。实现BeanFactoryAware 主要目的是为了获取Spring容器，如Bean通过Spring容器发布事件等
5. 如果Bean实现了ApplicationContextAwaer接口，Spring容器将调用setApplicationContext(ApplicationContext ctx)方法，将bean所在的应用上下文的引用传入进来。作用与BeanFactory类似都是为了获取Spring容器，不同的是Spring容器在调用setApplicationContext方法时会把它自己作为setApplicationContext 的参数传入，而Spring容器在调用setBeanDactory前需要程序员自己指定（注入）setBeanDactory里的参数BeanFactory
6. 如果Bean实现了BeanPostProcess接口，Spring将调用它们的postProcessBeforeInitialization（预初始化）方法

作用是在Bean实例创建成功后对进行增强处理，如对Bean进行修改，增加某个功能
7. 如果Bean实现了InitializingBean接口，Spring将调用它们的afterPropertiesSet方法，作用与在配置文件中对Bean使用init-method声明初始化的作用一样，都是在Bean的全部属性设置成功后执行的初始化方法。

8. 如果Bean实现了BeanPostProcess接口，Spring将调用它们的postProcessAfterInitialization（后初始化）方法。作用与6的一样，只不过6是在Bean初始化前执行的，而这个是在Bean初始化后执行的，时机不同
9. 经过以上的工作后，Bean将一直驻留在应用上下文中给应用使用，直到应用上下文被销毁
10. 如果Bean实现了DispostbleBean接口，Spring将调用它的destory方法，作用与在配置文件中对Bean使用destory-method属性的作用一样，都是在Bean实例销毁前执行的方法。

参考来自 frank-lam的github： 文章链接