Spring的了解

spring的学习

导论和思路

spring是什么？干什么的？为什么要用它，有没有更好的框架？

学习

一、ioc和aop

     spring是一个开源框架，除了注解，基本上没发现它的存在，侵入性很低，谈到spring一瞬间就会联想到ioc和aop，ioc是由控制反转、DI(依赖注入），aop是负责面向切面的编程思想。

控制反转：

传统Java SE程序设计，开发者都是自己来控制bean的加载和依赖，如果中间出现问题，整个环节就容易断掉。

spring控制反转，反转的概念为由原来开发者对于bean的创建和依赖进行主观控制，变为由spring进行控制和依赖，而且它会在你用到对应的bean时，帮你去依赖上。

• 原理：
       在初始化一个Spring容器时，Spring会解析spring的配置文件（applicationContext.xml）,从上到下解析到<bean id=””,class=””>时，根据标签中的class属性指定的类的全路径名找到该类并通过反射来创建该类的对象，并创建的对象存入到内置的Map容器中管理，其中存入map中的键是该标签中的id值，值是创建的对象。
• 获取对象过程：
       当通过context.getBeans(“id值”)方法来从容器中获取对象时，根据id从内置的Map中寻找是否有匹配的键值，如果有返回对象，如果没有抛出异常。

DI(依赖注入)：

举个例子吧：

public class ColdKill implements  Kill{

    private DaliyTask daliyTask;

    public ColdKill(){
        this.daliyTask=new DaliyTask ();
    }

    @Override
    public void play() {
        daliyTask.action();
    }
}

这个“冷血杀手”执行任务，当我们需要用到的时候，初始化它，然后执行他的任务。但是这个时候这个杀手不能执行保护的任务。

public class ColdKill implements  Kill{

    private DaliyTask daliyTask;

    public ColdKill(DaliyTask task){
        this.daliyTask=task;
    }

    @Override
    public void play() {
        daliyTask.action();
    }
}

public class IocTest {

    @Test
    public void test(){
        ColdKill coldKill = new ColdKill(new SaveFlower());
        coldKill.play();
    }
}

这个时候通过构造器，这样只要实现KillTask ，可以将不同杀手任务通过构造器参数传入。这些是spring的控制翻转和依赖注入，注入的方式三种：构造器注入,setter,接口。

AOP

aop是基于oop（oop是面向对象会导致大量代码的重复）的基础上进行完善，将那些与业务无关，但对多个对象影响的公共行为和逻辑，抽取并封装为一个可重用的模块。

aop的动态代理方式：jdk代理，cglib代理。
有动态代理方式，就会有静态代理，静态代理一句话就是：抽出公共行为和逻辑为一个接口，然后实现的时候注入对象，进行调用，今天这个不是我们的关键。

• jdk代理：

只提供接口的代理，不支持类的代理。代理业务类集成InvocationHandler，使用Proxy类，进行newProxyInstance进行控制接口方法的代理

public class DynamicProxy implements InvocationHandler {

   private Object target;

   @Override
   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
       System.out.println("JDK动态代理 监听开始");
       Object invoke = method.invoke(target, args);
       System.out.println("JDK动态代理，监听结束！");

       return invoke;
   }

   private Object getJdkProxy(Object targetObject) {
       this.target = targetObject;
       return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(), targetObject.getClass().getInterfaces(), this);
   }

   public static void main(String[] args) {
       DynamicProxy proxy = new DynamicProxy();
       Object jdkProxy = proxy.getJdkProxy(new DoSomeThing());
       DoSomeService d1 = (DoSomeService) jdkProxy;
       d1.please();
       StarThingService d2 = (StarThingService) jdkProxy;
       d2.refuse();
   }


}

public class DoSomeThing implements DoSomeService ,StarThingService{

   public void please(){
       System.out.println("邀请A明星参加我们的聚会");
   }

   @Override
   public void refuse() {
       System.out.println("A明星因事婉拒此次邀请");
   }
}

• cglib代理：

cglib代理目标类，相当于基于被代理的类，创建一个子类。

public class CglibProxy implements MethodInterceptor {
   private Object target;

   @Override
   public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
       System.out.println("Cglib 代理动态 监听开始");
       Object invoke = method.invoke(target, objects);
       System.out.println("Cglib 代理动态 监听结束");
       return invoke;
   }

   private Object getCglibProxy(Object interceptor) {
       this.target = interceptor;
       Enhancer enhancer = new Enhancer();
       enhancer.setSuperclass(target.getClass());
       enhancer.setCallback(this);
       return enhancer.create();
   }

   public static void main(String[] args) {
       CglibProxy proxy=new CglibProxy();
       DoSomeThing cglibProxy = (DoSomeThing)proxy.getCglibProxy(new DoSomeThing());
       cglibProxy.please();
   }


}

多个代理类大家可以自己推导一下

二、spring结构图

太多的文章说这个图，主要知道那个模块提供那些开发中需要的功能，核心模块：core

• 依赖关系及相关功能
  

Beanfactory与applicationcontext的区别

BeanFactory：
是Spring里面最低层的接口，提供了最简单的容器的功能，只提供了实例化对象和拿对象的功能；

ApplicationContext：
应用上下文，继承BeanFactory接口，它是Spring的一各更高级的容器，提供了更多的有用的功能；

1. 国际化（MessageSource）

2. 访问资源，如URL和文件（ResourceLoader）

3. 载入多个（有继承关系）上下文 ，使得每一个上下文都专注于一个特定的层次，比如应用的web层

4. 消息发送、响应机制（ApplicationEventPublisher）

5. AOP（拦截器）

两者装载bean的区别：

BeanFactory：

BeanFactory在启动的时候不会去实例化Bean，中有从容器中拿Bean的时候才会去实例化；

ApplicationContext：

ApplicationContext在启动的时候就把所有的Bean全部实例化了。它还可以为Bean配置lazy-init=true来让Bean延迟实例化

三、bean的生命周期

网上介绍很多偏底层，看看代码。转载一下

三、bean的作用域

类别	说明
singleton	在ioc容器中仅存在一个bean实例，bean以单例方式存在
prototype	每次从容器中调用bena，都会返回一个新的bean，是多例的
request	每次http请求创建一个新的bean，请求完成bean会被回收
session	与request类似，不同的是，session是国企后，bean随之失效回收
global-sesion	全局作用域，global-session和Portlet应用相关。当你的应用部署在Portlet容器中工作时，它包含很多portlet。如果你想要声明让所有的portlet共用全局的存储变量的话，那么这全局变量需要存储在global-session中。全局作用域与Servlet中的session作用域效果相同。