理解 Spring Framework中的IOC 与AOP

IOC

IOC使用前
早期，或者可以说是在我大一的时候，老师给我们上的javaweb课上时，比如一个用户的登录：

• JDBC创建数据库，UserDao注入UserService，或者说UserService调用UserDao。

• 然后UserService注入Servlet中，也可以说Servlet调用UserService

• 我们发现每次下一层调用上一层都会自己的这一层，new一个上一层对象，比如UserService调用UserDao时，需要在UserService中new UserDao();

• 这样的后果必然造成一层依赖另一层，导致该模块的耦合度变高，若后期需求改变，修改的代码量可想而知会很大。所以说程序的扩展性大打折扣。
  
  IOC使用后
  Spring的横空出世解决了这个强耦合的问题

   1.首先所有的层都DI(依赖注入)到Spring中。
   2.哪一层想用，@Autowired就可以使用了
  

总的来说你只需在每一层加上相应的注解，spring扫描到了，就放入容器，需要使用时就@Autowired自动导入进去，就能使用了。

AOP

静态代理
springAOP指的是在spring中的AOP，什么是AOP，相对于java中的面向对象（oop），在面向对象中一些公共的行为，像日志记录，权限验证等如果都使用面向对象来做，会在每个业务方法中都写上重复的代码，造成代码的冗余。而AOP指的是面向切面编程，定义一个切面，用切面去切相应的方法，就可以织入相关的逻辑。面向切面编程使用代理模式。
这里就用一段代码来描述常用的代理方式。

package cn.com.staticProxy;
/**
 * * 
*<p>Title: IUserDao</p>
* <p>Description:公共的接口</p>
* <p>Company: </p>
* @author Administrator
 */
public interface IUserDao {

    void save();
    void find();
}

然后是代理类和被代理类，先看被代理类.

package cn.com.staticProxy;

public class UserDao implements IUserDao{
/**
 * 被代理类或者叫代理目标类
 */
    @Override
    public void save() {
        // TODO Auto-generated method stub
        
        System.out.println("模拟保存用户");
        
    }

    @Override
    public void find() {
        // TODO Auto-generated method stub
        System.out.println("模拟查找用户");
        
    }

}

从被代理类上可以看到，被代理类要做的就是save和find操作，如果不使用代理模式，那么我们的使用方式则是直接使用，如下

package cn.com.staticProxy;
/**
 * * 
*<p>Title: Test2</p>
* <p>Description:直接使用被代理类 </p>
* <p>Company: </p>
* @author Administrator
 */
public class Test2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        IUserDao udp=new UserDao();
        udp.save();
        System.out.println("-------------------");
        udp.find();
    }

}

通过测试方法，可以得出执行方法的结果如下，

模拟保存用户
-------------------
模拟查找用户

下面看代理类，

package cn.com.staticProxy;

public class UserDaoProxy implements IUserDao {

    private UserDao ud = new UserDao();

    @Override
    public void save() {
        // TODO Auto-generated method stub

        System.out.println("代理操作，开启事务");
        ud.save();
        System.out.println("代理操作，关闭事务");
    }

    @Override
    public void find() {
        // TODO Auto-generated method stub
        System.out.println("代理操作，开启事务");
        ud.find();
        System.out.println("代理操作，关闭事务");
    }

}

可以看到代理类的实现逻辑是在代理类中持有一个被代理类的实例，通过被代理类实例调用被代理对象的方法，另外在方法之前前后均可加入其它的方法处理逻辑，

最后，看使用代理类的测试方法，

package cn.com.staticProxy;

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        IUserDao udp=new UserDaoProxy();
        udp.save();
        System.out.println("-------------------");
        udp.find();
    }

}

返回的执行结果如下，

代理操作，开启事务
模拟保存用户
代理操作，关闭事务
-------------------
代理操作，开启事务
模拟查找用户
代理操作，关闭事务

对比，使用静态代理和不使用静态代理，可以发现使用了代理之后，可以在被代理方法的执行前或后加入别的代码，实现诸如权限及日志的操作。

但，静态代理也存在一定的问题，如果被代理方法很多，就要为每个方法进行代理，增加了代码维护的成本。有没有其他的方式可以减少代码的维护，那就是动态代理。

动态代理

JDK提供了动态代理的方式，可以生成代理类，被代理类和接口沿用静态代理中的IUserDao和UserDao，UserDao为被代理类，下面看代理类，

package cn.com.dynamicProxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

import cn.com.staticProxy.IUserDao;
import cn.com.staticProxy.UserDao;
/**
 * * 
*<p>Title: DynamicProxy</p>
* <p>Description: 动态代理类</p>
* <p>Company: </p>
* @author Administrator
 */
public class DynamicProxy implements InvocationHandler{
    //被代理类的实例
    private IUserDao iud=null;

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // TODO Auto-generated method stub
        Object result=null;
        System.out.println("开始JDK动态代理");
        method.invoke(iud, args);
        System.out.println("结束JDK动态代理");
        return result;
    }
    //构造方法
    public DynamicProxy(IUserDao iud){
        this.iud=iud;
    }
    
}

需要实现JDK中的InvocationHandler接口，实现其中的invoke方法，在此方法中通过反射的方式调用被代理类的方法，可以在方法执行前或后进行别的处理，下面看测试代码

package cn.com.dynamicProxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import cn.com.staticProxy.IUserDao;
import cn.com.staticProxy.UserDao;

public class Test2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        UserDao ud=new UserDao();
        
        DynamicProxy dp=new DynamicProxy(ud);
        
        //生成代理对象
        IUserDao iud=(IUserDao)Proxy.newProxyInstance(ud.getClass().getClassLoader(), ud.getClass().getInterfaces(), dp);
        iud.save();
        System.out.println("--------------");
        iud.find();
        
    }

    
}

在测试代码中通过Proxy类的newProxyInstance方法，生成代理类的实例iud，需要三个参数，第一个为被代理类的类加载器，第二个为被代理类实现的接口，第三个则为invocationHandler的实现类，这样就生成了代理对象，然后通过代理对象调用方法执行结果如下，

开始JDK动态代理
模拟保存用户
结束JDK动态代理
--------------
开始JDK动态代理
模拟查找用户
结束JDK动态代理