Spring_AOP_基本原理

1.目录结构

2.User

package com.cloud.spring.model;

/**
 * @author cloud
 * @data 2016年5月13日
 * @version 1.0
 * @description:普通的JavaBean
 */
public class User {
    private String username;
    private String password;
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
}

 

3.UserDAO

package com.cloud.spring.dao;

import com.cloud.spring.model.User;

/**
 * @author cloud
 * @data 2016年5月13日
 * @version 1.0
 * @description:定义接口，定义规范，必须实现save方法
 */
public interface UserDAO {
    public void save(User user);
}

 

4.UserDAOImpl

package com.cloud.spring.dao.imp;

import com.cloud.spring.dao.UserDAO;
import com.cloud.spring.model.User;

/**
 * 
 * @author cloud
 * @data 2016年5月13日
 * @version 1.0
 * @description:实现接口，重写方法
 */
public class UserDAOImpl implements UserDAO {

    public void save(User user) {
        System.out.println("user saved!");
    }

}

package com.cloud.spring.dao.imp;

import com.cloud.spring.dao.UserDAO;
import com.cloud.spring.model.User;

/**
 * 
 * @author cloud
 * @data 2016年5月13日
 * @version 1.0
 * @description:继承UserDAOImpl,重写方法，加所需要的逻辑代码,
 */
public class UserDAOImpl2 extends UserDAOImpl {

    public void save(User user) {
        //这样就实现了在原来的基础上加代码的功能
        System.out.println("save start...!");
        super.save(user);
    }

}

package com.cloud.spring.dao.imp;

import com.cloud.spring.dao.UserDAO;
import com.cloud.spring.model.User;

/**
 * 
 * @author cloud
 * @data 2016年5月13日
 * @version 1.0
 * @description:使用组合的方式实现在切面的功能,加自己的逻辑代码
 */
public class UserDAOImpl3 implements UserDAO {

    private UserDAO userDAO =  new UserDAOImpl();
    public void save(User user) {
        System.out.println("save start...!");
        userDAO.save(user);
    }

}

 

5.UserService

package com.cloud.spring.service;
import com.cloud.spring.dao.UserDAO;
import com.cloud.spring.model.User;


/**
 * 
 * @author cloud
 * @data 2016年5月13日
 * @version 1.0
 * @description:真正的业务处理
 */
public class UserService {
    private UserDAO userDAO;  
    public void add(User user) {
        userDAO.save(user);
    }
    public UserDAO getUserDAO() {
        return userDAO;
    }
    public void setUserDAO(UserDAO userDAO) {
        this.userDAO = userDAO;
    }
}

 

6.TestAop

package com.cloud.spring.test;

import java.lang.reflect.Proxy;

import org.junit.Test;

import com.cloud.spring.aop.LogIntercepter;
import com.cloud.spring.dao.UserDAO;
import com.cloud.spring.dao.imp.UserDAOImpl;
import com.cloud.spring.model.User;

public class TestAOP {

    @Test
    public void test() {
        //设置被代理对象
        UserDAO userDAO = new UserDAOImpl();
        LogIntercepter li = new LogIntercepter();
        li.setTarget(userDAO);
        
        //创建代理对象
        UserDAO userDAOProxy = (UserDAO)Proxy.newProxyInstance(userDAO.getClass().getClassLoader(), userDAO.getClass().getInterfaces(), li);
        userDAOProxy.save(new User());
    }
    
    //面向切面编程，是对面向对象编程的补充，如果说OOP是横向编程，那么AOP就是纵向编程，中间拦截后在进行后续处理
    //创建代理对象，在其中添加被代理对象
    //执行代理对象的逻辑代码
    //将后续执行过程交给被代理对象正常执行相应的逻辑代码,而被代理对象并不知道中间被拦截
    //值得注意的是代理对象和被代理对象都实现同一个接口

}

 

7.代理类LogIntercepter

package com.cloud.spring.aop;

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

//拦截器
public class LogIntercepter implements InvocationHandler {

    private Object target;

    public Object getTarget() {
        return target;
    }

    public void setTarget(Object target) {
        this.target = target;
    }

    //所有的方法都进行拦截，在方法执行之前都要调用beforeMethod方法
    private void beforeMethod(Method m) {
        System.out.println(m.getName() + "  start@" + new Date());
    }
    
    //所有的方法都进行拦截，在方法执行之后都要调用afterMethod方法
        private void afterMethod(Method m) {
            System.out.println(m.getName() + "  end@"+new Date());
        }

    @Override
    public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {
        this.beforeMethod(m);
        m.invoke(target, args);
        this.afterMethod(m);
        return null;
    }

}