jdk动态代理

具体文件格式

 

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 ”

xsi ：schemaLocation = “

http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd “ >

<！ - 配置事务管理器- >

< bean id = “tranction” class = “proxy.tranction.tranction” > </ bean >

<！ - 配置道- >

< bean id = “employeedao” class = “proxy.dao.impl.employeedaoimpl” > </ bean >

<！ - 配置加强事务管理器代理- >

< bean id = “handler” class = “proxy.tranctionhandler.tranctionhandler” >

< property name = “tx” ref = “tranction” > </ property >

< property name = “target” >

< bean class = “proxy.service.impl.employeeserviceimpl” >

< property name = “dao” ref = “employeedao” > </ property >

</ bean >

</ property >

</ bean >

</ beans >

 

 

员工类

package proxy.domain;

 

公共级员工{

}

 

employeedao接口

package proxy.dao;

 

import proxy.domain.employee;

 

public interface employeedao {

// 保存方法

void save（employee emp）;

// 更新方法

void update（employee emp）;

}

 

 

的EmployeeService接口

package proxy.service;

 

import proxy.domain.employee;

 

public interface employeeservice {

// 保存方法

void save（employee emp）;

// 更新方法

void update（employee emp）;

}

 

employeedaoimpl实现类

package proxy.dao.impl;

 

import proxy.dao.employeedao;

import proxy.domain.employee;

 

public class employeedaoimpl implements employeedao {

@覆盖

public void save（employee emp）{

系统。out .println（“ 保存员工”）;

}

 

@覆盖

public void update（employee emp）{

系统。out .println（“ 更新员工”）;

}

}

 

 

employeeserviceimpl实现类

package proxy.service.impl;

 

import proxy.dao.employeedao;

import proxy.domain.employee;

import proxy.service.employeeservice;

 

public class employeeserviceimpl实现 employeeservice {

私人 employeedao道 ;

 

public void setDao（employeedao dao）{

这个。dao = dao;

}

 

@覆盖

public void save（employee emp）{

dao .save（emp）;

}

 

@覆盖

public void update（employee emp）{

dao .update（emp）;

}

}

 

 

 

tranction事务管理类

package proxy.tranction;

 

公共阶级转移{

public void begin（）{

系统。out .println（“ 惟有身处卑微的人，最有机缘看到世态人情的真相。一个人不想攀高就不怕下跌，也不用倾压排挤，可以保其天真，成其自然，潜心一志完成自己能做的事。“）;

}

public void commit（）{

系统。out .println（“ 少年贪玩，青年迷恋爱情，壮年汲吸于成名成家，暮年自安于自欺欺人。人寿几何，顽铁能炼成的精金，能有多少？我们曾如此渴望命运的波澜，到最后才发现：人生最曼妙的风景，竟是内心的淡定与从容;我们曾如此期盼外界的认可，到最后才知道：世界是自己的，与他人毫无关系。“）;

}

public void rollback（）{

系统。out .println（“ 我和谁都不争，和谁争我都不屑。简朴的生活，高贵的灵魂是人生的至高境界。”）;

}

}

 

 

tranctionhandler事务管理增强类

package proxy.tranctionhandler;

 

import proxy.tranction.tranction;

 

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

 

// 事务增强操作类

public class tranctionhandler实现 InvocationHandler {

 

私有对象目标 ; // 真实对象，被代理对象（employeeserviceimpl ）

私人转移 tx ;

 

public void setTarget（Object target）{

这个。target = target;

}

 

public void setTx（tranction tx）{

这个。tx = tx;

}

 

// 创建一个代理类对象

public < T > T getobject（）{

对象obj =代理。newProxyInstance（target .getClass（）。getClassLoader（），// 类加载器：sun.misc.Launcher$AppClassLoader@18b4aac2

target .getClass（）。getInterfaces（）， // 真实对象实现的接口：[Ljava.lang.Class; @ 35fc6dc4

这个）; // 增强类型的对象（proxy.tranctionhandler.tranctionhandler@35fc6dc4）

系统。out .println（“ 类加载器---- ” “ + target .getClass（）。getClassLoader（））;

系统。out .println（“ 真实对象的接口----- ” “ + target .getClass（）。getInterfaces（））;

return（ T）obj;

}

@覆盖

public Object invoke（Object proxy，Method method，Object [] args）抛出 Throwable {

系统。out .println（method + “” + args）;

Object ret = null ;

tx .begin（）;

尝试 {

ret = method.invoke（target，args）; // 执行真实对象的方法：public abstract void proxy.service.employeeservice.save（proxy.domain.employee）

tx .commit（）;

}catch (Exception e){

tx.rollback();

e.printStackTrace();

}

return ret;

}

}

 

 

test测试类

package proxy.test;

 

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import proxy.domain.employee;

import proxy.service.employeeservice;

import proxy.tranctionhandler.tranctionhandler;

 

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration("classpath:applicationContext.xml")

public class test {

@Autowired

@Qualifier("handler")

private tranctionhandler handler;

@Test

public void testsave(){

employeeservice service=handler.getobject();//代理对象：class com.sun.proxy.$Proxy12

System.out.println(service.getClass());

service.save(new employee());

}

 

@Test

public void testupdate(){

employeeservice service=handler.getobject();//代理对象：class com.sun.proxy.$Proxy12

System.out.println(service.getClass());

service.update（new employee（））;

}

// 总结：当调用保存或者更新方法时，底层其实在调用的invoke 方法

}

 

 

测试结果为：