JAVAEE企业级开发（IOC概念\AOP实现）

JAVAEE

Spring：一个装配机器，一个Bean工厂，负责生成对象并设置好属性（如作用域）给你。

IOC:控制反转，将创建对象的工作交给spring容器，控制权即控制选择怎样去实现接口，反转就是控制权由程序（程序中的编码）转向了外部容器（Spring）。

scope作用域：singleton一个对象，prototype多个对象

AOP：面向切面编程，是面向对象编程的一种补充。将分散在各种方法中的重复代码（如日志记录，事务处理）提取，如很多类继承了父类方法（OOP），一旦父类方法改变子类都需要改变，大大增加了工作量，使用AOP就可以简化这类工作，AOP是OOP的补充与延伸。

开发人员可以专心处理业务，错误处理，日志记录等工作交给AOP处理，可以说是专门用一个类来处理，提高开发效率，增强代码可维护性。

AOP术语： 此处较为抽象。Aspect（切面，程序中插入类，类用于事务处理等）。Joinpoint（连接点，即程序中方法的调用）。Pointcut（切入点，类或方法名，如通知要应用到有@的方法中 ，那么所有满足这个规则的方法都是切入点）。Advice（通知/增强处理，可以理解为切面类中的方法）。Target Object（目标对象，指所有被通知的对象，也被称为增强对象，如果AOP框架采用的是动态AOP实现，则该对象是一个代理对象）。Proxy（代理，将通知应用到目标对象后，被动态创建的对象）。Weaving（织入，将切面代码插入到目标对象上，从而生成代理对象的过程）。

AOP的实现：

JDK代理，需实现接口：

创建UserDao接口

package cn.edu.gues.jdkAOP;

public interface UserDao {

public void addUser();

public void deleteUser();

}

创建实现类UserDaoImpl：

package cn.edu.gues.jdkAOP;

 

public class UserDaoImpl implements UserDao {

//目标类

@Override

public void addUser() {

System.out.println("添加用户");

 

}

 

@Override

public void deleteUser() {

System.out.println("删除用户");

 

}

 

}

 

创建切面类MyAspect ，类中整合其他类重复使用的代码，如日志记录等

package cn.edu.aspect;

//切面类，可以存在多个通知Advice(即增强的方法)

public class MyAspect {

 

public void check_Permissions(){

System.out.println("模拟检查权限...");

}

public void log(){

System.out.println("模拟记录日志...");

}

}

创建代理类JDKProxy ：

package cn.edu.gues.jdkAOP;

 

import java.lang.reflect.InvocationHandler;

/**

 * JDK代理类

 *

 * **/

public class JDKProxy implements InvocationHandler {

    //声明目标类接口

private UserDao userDao;

//创建代理方法

public Object createProxy(UserDao userDao){

this.userDao=userDao;

//1.类加载器

ClassLoader classLoader=JDKProxy.class.getClassLoader();

//2.被代理对象实现的所有接口

Class<?>[] clazz = userDao.getClass().getInterfaces();

//3.使用代理类，进行增强返回的是代理后的对象

return Proxy.newProxyInstance(classLoader, clazz, this);

 

}

/*

 * 所有动态代理类的方法调用，都会交由invoke()方法去处理

 * proxy就是被代理后的对象

 * method就是将要被执行的方法信息(反射)

 * args执行方法时需要的参数

 * */

public Object invoke(Object arg0, Method arg1, Object[] arg2) throws Throwable {

//声明切面

MyAspect aspect=new MyAspect();

//前增强

aspect.check_Permissions();

 

//在目标类上面调用方法，并传入参数

Object obj=arg1.invoke(userDao, arg2);

 

//后增强

aspect.log();

return obj;

 

}

 

}

编写测试类JDKTest

package cn.edu.gues.jdkAOP;

 

import cn.edu.aspect.MyAspect;

 

public class JDKTest {

 

public static void main(String[] args) {

 

//创建代理对象

JDKProxy jdkProxy=new JDKProxy();

//创建目标对象

UserDao userDao=new UserDaoImpl();

//从代理对象中获取增强后的目标对象

UserDao userDao2=(UserDao) jdkProxy.createProxy(userDao);

//执行方法

userDao2.addUser();

userDao2.deleteUser();

 

}

 

}

 

运行结果图

 

 

 

CGLIB代理，对类增强，不用实现接口：

创建UserDao类：

package cn.edu.cglib;

//目标类

public class UserDao {

public void addUser() {

System.out.println("添加用户");

}

public void deleteUser() {

System.out.println("删除用户");

}

}

创建切面类MyAspect ，类中整合其他类重复使用的代码，如日志记录等

package cn.edu.cglib;

//切面类，可以存在多个通知Advice(即增强的方法)

public class MyAspect {

 

public void check_Permissions(){

System.out.println("模拟检查权限...");

}

public void log(){

System.out.println("模拟记录日志...");

}

}

创建代理类CglibProxy:

package cn.edu.cglib;

import java.lang.reflect.Method;

import org.springframework.cglib.proxy.Enhancer;

import org.springframework.cglib.proxy.MethodInterceptor;

import org.springframework.cglib.proxy.MethodProxy;

 

import cn.edu.aspect.MyAspect;

//代理类

public class CglibProxy implements MethodInterceptor {

//代理方法

public Object createProxy(Object target){

//创建一个动态类对象

Enhancer enhancer=new Enhancer();

//确定需要增强的类设置其父类，即确定目标对象

enhancer.setSuperclass(target.getClass());

//添加回调函数

enhancer.setCallback(this);

//返回创建的代理类

return enhancer.create();

}

/*

 * proxy:CGlib根据指定父类生成的代理对象

 * method：拦截的方法

 * args：拦截方法的对象数组

 * methodProxy：方法的代理对象，用于执行父类的方法

 * */

@Override

public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

//创建切面对象

MyAspect myAspect=new MyAspect();

//前增强

myAspect.check_Permissions();

//目标方法执行

Object obj = methodProxy.invokeSuper(proxy, args);

//后增强

myAspect.log();

return obj;

}

 

}

创建测试类TestCglib：

package cn.edu.cglib;

 

public class TestCglib {

 

public static void main(String[] args) {

//创建代理对象

CglibProxy cglibProxy=new CglibProxy();

//创建目标对象

UserDao userDao=new UserDao();

//获取增强后的目标对象

UserDao userDao1 = (UserDao) cglibProxy.createProxy(userDao);

//执行方法

userDao1.addUser();

userDao1.deleteUser();

 

}

 

}

运行结果图

 

由于IOC控制反转较简单，也有很多博客，所以这里放上了AOP动态代理的代码和说明。

感谢阅读，本博客仅供个人学习，请勿用于商业用途。