AOP框架总结

AOP框架总结

 

1.什么是AOP框架？

AOP编程是面向切面编程，需要配置AOP框架实现

是面向切面编程就是通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术

 

面向切面编程主要是为了将一些跟业务逻辑无关（不是真正核心）的代码进行统一的编写，要的时候可以简单地动态的将切面加入，不需要的时候就可以简单的挪走，为了更好的维护系统

 

2.AOP框架的原理及运用

 

AOP用来封装横切关注点，具体可以在下面的场景中使用：

权限 缓存 错误处理 调试 记录跟踪 持久化 同步 事务 等等

 

 

编写一个接口，里面写两个方法，一个是beforeAdvice()前通知方法，另一个是afterAdvice()后通知方法。

实现类为LogAdvice是一个通知实现类，beforeAdvice（）的实现方法为打印日志更改的开始时间

System.out.println("start time:"+System.currentTimeMillis());

afterAdvcice()的实现方法为打印日志更改的时间

System.out.ptintln("end time :"+System.currentTimeMillis());

/*

 

 

*/

 

原理：

核心就是使用Java中的代理模式

把切面挪放到代理中去实现，让真正的业务代码只关注自己业务的本身

/*

代理对象：增强后的对象

目标对象：被增强的对象

 

 

静态代理：在使用静态代理时,被代理对象与代理对象需要一起实现相同的接口或者是继承相同父类，因此要定义一个接口或抽象类.

 

 

角色分析：

• 抽象角色：一般会使用接口或者抽象类来解决 共同要实现的租房接口
• 真实角色：被代理的角色 房东
• 代理角色：代理真实角色，代理真实角色后，会做一些附属操作 中介角色

附属操作：即要实现的具体操作，如何签合同之类的操作

• 客户：访问代理对象的人 要租房的人

使用代理对象要做的一些操作

 

 

//接口：该接口是静态代理要代理的事情，例如上图所示的租房

public interface Rent{

 

public void rent();

}

//真实角色：要做的是出租房子的业务 房东

public class Host implements Rent{

 

public void rent(){

System.out.println("房东要出租房子");

}

}

 

//代理角色

public class Proxy implement Rent{

 

//多用组合少用继承的原则。可直接将Host的属性拿来使用

private Host host;

 

public Proxy();

 

public Proxy(Host host){

this.host=host;

}

 

//此时private传进来什么客户，就调用哪个客户来租房

public void rent(){

seeHouse();

host.rent();

HeTong();

fare();

}

//看房

public void seeHousr(){

System.out.println("中介带你看房");

}

//签合同

public void HeTong(){

System.out.println("签租赁合同");

}

//收中介费

public void fare(){

System.out.println("收中介费");

}

}

//业务程序

public class Client{

public static void main(String args[]){

 

//房东要出租房子

Host host = new Host();

//代理，中介帮房东租房子，但是代理一般会有一些附属操作，例如给客户看房，签合同等

Proxy proxy = new Proxy(host);

//你不需要面对房东，直接找中介租房即可！

proxy.rent();

}

}

代码步骤

 

代理模式的好处：

1.可以使得真实角色的操作更加纯粹，代理真实角色以后，不需要关注一些公共的业务

2.公共业务就直接交给代理角色，实现了业务的分工

3.公共业务发生扩展的时候，方便集中管理！

 

缺点：

1.一个真实角色就会产生一个代理角色，代码量就会翻倍，开发效率会变低

 

为什么要使用代理模式？

在Java中，是对修改关闭，扩展开放的，代理模式可以让我们在不修改原始代码的同时，扩展其他的功能

 

 

// 接口

interface IStar {

void sing();

}

 

// 真实对象

class LDHStar implements IStar {

@Override

public void sing() {

System.out.println("刘德华唱歌");

}

 

}

 

// 代理类需要有真实对象的控制权 (引用)

class ProxyManger implements IStar {

// 真实对象的引用

private IStar star;

public ProxyManger() {

super();

}

 

public ProxyManger(IStar star) {

super();

this.star = star;

}

@Override

public void sing() {

　　　　　　System.out.println("唱歌前准备");

　　　 star.sing();

　　　　System.out.println("善后工作"); }

}

class Test{

public static void main(String[] args) {

// 创建明星对象

IStar ldh = new LDHStar();

ProxyManger proxy = new ProxyManger(ldh);

proxy.sing();

}

}

*/

动态代理

1.动态代理和静态代理角色一样

2.动态代理的代理类是动态生成的，不是我们直接写好的

3.动态代理分两大类：基于接口的动态代理，基于类的动态代理

1. 基于接口----jdk动态代理
2. 基于类：cglib
3. java字节码：javasist

需要了解两个类 Proxy 、InvocationHandler:调用处理程序

 

 

//等会使用这个类，自动生成代理类

public class ProxyInvocationHandler implements InvocationHandler({

//被代理的接口

private Object target;

public void setTarget(Object target){

this.target=target;

}

 

//生成得到代理类

public Object getProxy(){

return Proxy.newProxyInstance(this.getClass().getClassLoader(),

target.getClass().getIntergace,this);

}

 

//处理代理实力，并返回结果

public Object invoke(Object proxy,Method method,Object[] args)throw Throwable{

log(method.getName);

Object result = method.invoke(target,args);

return result;

}

public void lkog(Sting msg){

System.out.println("执行了"+msg+"方法");

}

}

 

 

/* 实现*/

public class Client{

public static void main(String args[]){

//真实角色

UserServiceImpl userService = new UserService();

//代理角色， 不存在

ProxyInvocationHandler pih =new ProxyInvocationHandler();

 

pih.setTarget(userService); //设置要代理的对象

 

//动态生成代理类

UserService proxy=(UserService)pih.getProx0y();

proxy.add();

}

 

}

3.AOP框架在底层的实现方式

 

4.完成一个使用了AOP框架的服务器服务功能