spring核心

spring核心有两部分：

（1）控制反转 ioc：

* 比如现在有普通类，在这个类里面有普通的方法，调用这个类里面的普通的方法，需要创建类对象，使用对象调用方法。

* 创建类的对象，使用原始方式new对象。使用ioc实现对象创建，不需要手动new对象，通过配置文件方式创建对象

** 把对象创建交给spring配置

 

（2）面向切面 aop：

* 不通过修改源代码方式增强类里面的方法

* aop底层动态代理

1 aop：面向切面（方面）编程，不通过修改源代码方式实现功能扩展

（1）拦截器是aop思想

 

2 AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码

（1）纵向机制：BaseServlet

3 aop底层使用动态代理实现（横向机制）

（1）使用动态代理作用增强类里面的方法，不需要修改源代码实现

（2）分成两种情况

第一种有接口情况

l  使用jdk动态代理

l  使用jdk动态代理，创建接口实现类代理对象

 

第二种没有接口情况

l  使用cglib动态代理

l  使用cglib动态代理方式，创建类的子类代理对象

1 Jdk动态代理代码（有接口）

/**

 * 写jdk动态代理有接口情况

*/

publicclass JDKProxy {

 

    publicstaticvoid main(String[]args) {

       //生成接口实现类代理对象

       Class[] interfaces = {Bird.class};

//     Proxy.newProxyInstance(JDKProxy.class.getClassLoader(),interfaces, new InvocationHandler() {

//        

//         @Override

//         public Object invoke(Objectproxy,Method method, Object[] args) throws Throwable {

//            // TODO Auto-generated methodstub

//            return null;

//         }

//     });

      

       Bird bird = (Bird) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(),interfaces,new Ying(new Diao()));

       bird.fly();

    }

}

 

class Yingimplements InvocationHandler {

   

    //增强diao里面的方法，得到diao对象

//  private Diao diao;

//  public Ying(Diao diao) {

//     this.diao = diao;

//  }

   

    private Birdbird;

    public Ying(Birdbird) {

       this.bird =bird;

    }

 

    public Object invoke(Objectproxy, Methodmethod, Object[]args) throws Throwable {

       //增强逻辑

       //1调用diao里面fly方法

       bird.fly();

      

//     String methodname =method.getName();

//     if("fly".equals(methodname)){

//         method.invoke(proxy,args);

//     }

      

       //2写增强逻辑

       System.out.println("ying fly20m.........");

       returnnull;

    }

   

}

 

//定义接口

interface Bird {

    publicvoid fly();

}

 

//接口实现类

class Diaoimplements Bird {

 

    publicvoid fly() {

       System.out.println("diao fly10m.........");

    }

}

2 cglib动态代理（没有接口）

第一步 创建类，实现接口 MethodInterceptor

第二步实现接口里面的方法intercept，在这个方法里面写增强的逻辑

 

第三步在类里面，创建方法，让这个方法返回子类代理对象

publicclass CGLib {

 

    publicstaticvoid main(String[]args) {

       MyUserDao myUserDao = new MyUserDao();

       UserDao userDao = myUserDao.createUserDao();

       userDao.find();

    }

}

 

//增强UserDao类里面find方法

class MyUserDaoimplements MethodInterceptor {

 

    //创建方法，让这个方法返回子类代理对象

    public UserDao createUserDao() {

       Enhancer enhancer = new Enhancer();

       enhancer.setSuperclass(UserDao.class);

       enhancer.setCallback(this);

       return (UserDao)enhancer.create();

    }

   

    //实现接口里面的方法

    public Object intercept(Objectobj, Method method, Object[] objects, MethodProxymethodProxy) throws Throwable {

       //让UserDao类里面find方法执行

       methodProxy.invokeSuper(obj,objects);

       //增强逻辑

       System.out.println("增强.................");

       returnnull;

    }

}

 

class UserDao {

    publicvoid find() {

       System.out.println("userdaofind.........");

    }

}