Spring 面向切面 代理

Aop(Aspect Oriented Programming), 即面向切面编程，可以说是OOP的补充和完善，与OOP有些区别，

AOP技术恰恰相反，它利用一种称为"横面"的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用的模板，并将其命名为"Aspect"，即切面，所谓"切面",简单说就是那些与业务无关，却为业务模板所公共调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模板之间的耦合度，并有利于未来的可操作性和可维护性。

给大家简单介绍一下一种模式：代理模式，分别在java，spring 中

Java中的静态代理模式：

实现步骤：

1 建立一个接口

package com.zking.proxy;

public interface Istr {
	
    public void sing();
}

 

2创建类实现接口

package com.zking.proxy;
/*
 * 明星类
 */
public class Lyf implements Istr{
	
	
	@Override
	public void sing() {
		System.out.println("这就是灌篮!");	
	}

}

3创建代理类实现接口(构造方法中要求传入接口作为参数)

package com.zking.proxy;
/**
 * 
 * @author 助理类
 *
 */
public class  zxj  implements Istr{
	
    private Istr istr;
      
	public zxj(Istr istr) {
		super();
		this.istr = istr;
	}

	@Override
	public void sing() {
		istr.sing();
	}

}

4测试类调用代理类进行测试

package com.zking.proxy;

public class Temp {

	public static void main(String[] args) {
//		Istr lyf=new Lyf();
//		zxj n=new zxj(lyf);
//		n.sing();
//		Istr fz=new FZ();
//		zxj n1=new zxj(fz);
//		n1.sing();
		
	}
}

 

举一个列子：明星，助理，具体明星，就是明星是一个接口，一个抽象类，助理去实现代理，让某个具体明星实现代理的东西，

 

 

Spring 中的动态代理模式：

1创建一个接口

package com.zking.proxy3;

public interface Iperson {
	//睡觉的方法
     public void sleep();
     //add的方法
     public void personAdd();
}

2实现接口的类 XIaoMing类

package com.zking.proxy3;

public class XiaoMing implements Iperson{

	@Override
	public void sleep() {
	System.out.println("睡觉");
		
	}

	@Override
	public void personAdd() {
		System.out.println("add");
		
	}

	
}

3 在applicationContext.xml里面写配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:util="http://www.springframework.org/schema/util"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.3.xsd">
<!-- 配置一个目标 -->		
<bean id="xm" class="com.zking.proxy3.XiaoMing"></bean>

<!-- 配置一个混合的代理 -->
<bean id="myproxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<!-- 引入目标 -->
<property name="target" ref="xm"></property>

<!-- 代理类的接口 -->
  <property name="proxyInterfaces">
  <list>
  <value>com.zking.proxy3.Iperson</value>
  </list>
  </property>
 
</bean>

</beans>

4测试类 

package com.zking.proxy3;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Temp3 {
	@Test
	public void SpringBean() {
     ApplicationContext ac= new ClassPathXmlApplicationContext("applicationContext.xml");
     Iperson ip=(Iperson) ac.getBean("myproxy");
     ip.sleep();
     //ip.personAdd();
	}
}

以上就是java的静态代理，spring的动态代理。