Spring AOP 最終版實現
來源：程序員人生 發布時間：2016-06-21 08:55:56 閱讀次數：3709次
引言
Spring AOP 是面向切面編程，通過預編譯方式和運行期動態代理實現程序功能的統1保護的1種技術。AOP是OOP的延續，是軟件開發中的1個熱門，也是Spring框架中的1個重要內容，是函數式編程的1種衍生范型。利用AOP可以對業務邏輯的各個部份進行隔離，從而使得業務邏輯各部份之間的耦合度下降，提高程序的可重用性，同時提高了開發的效力。
其實，我們在系統中通過AOP實現權限、日志、異常等等非業務服務橫切到我們的業務服務中，并且在不修改代碼的情勢，通常情況要是需要修改XML文件的，而且，當我們修改了非業務服務的時候，所有的業務服務中的代碼都會修改。
代碼實現：
目錄：
AOPClient：
package com.tgb.client;
import com.tgb.config.ClassPathXmlApplicationContext;
import com.tgb.config.ContainerBeans;
import com.tgb.dao.UserDao;
import com.tgb.domain.User;
/**
* AOP效果測試
* @ClassName: AopClientTest
* @Description:
* @author [qmx]
* @date
*
*/
public class AopClient {
public static void main(String[] args) throws Exception {
ContainerBeans factory = new ClassPathXmlApplicationContext();
User user = new User();
user.setUserName("hanyankun");
Object proxyObject = factory.getBean("UserDao");
UserDao userDao = (UserDao) proxyObject;
System.out.println("----啟用aop1");
// userDao.before(user);
userDao.update(user);
userDao.save(user);
//
}
}
ClientTest：
package com.tgb.client;
import com.tgb.config.ClassPathXmlApplicationContext;
import com.tgb.config.ContainerBeans;
import com.tgb.dao.StudentDao;
import com.tgb.dao.TeacherDao;
import com.tgb.daoImpl.StudentDaoImpl;
import com.tgb.domain.User;
/**
* 容器效果測試，測試增刪對象
* @ClassName: ClientTest
* @Description: TODO(這里用1句話描寫這個類的作用)
* @author [qmx]
* @date
*
*/
public class ClientTest {
public static void main(String[] args) throws Exception {
ContainerBeans containerBeans = new ClassPathXmlApplicationContext();// new
// 為
// 裝配容器進程
User user = new User();
user.setUserName("hanyankun"); // 參數設置
containerBeans.printAllbeanId();
System.out.println("\n");
//增加對象
StudentDao studentrDao = new StudentDaoImpl();
containerBeans.put("studentDao", studentrDao);
System.out.println("----放入對象-studentDao---");
containerBeans.printAllbeanId();
System.out.println("\n");
//獲得添加的對象
System.out.println("-----拿出來的studentDao-履行方法--syaName-");
StudentDao studentrDaoBean = (StudentDao) containerBeans.getBean("studentDao");
TeacherDao teacherDao = (TeacherDao) containerBeans.getBean("TeacherDao");
teacherDao.save(user);
studentrDaoBean.syaName();
System.out.println("\n");
//刪除對象測試
System.out.println("-----刪除對象TeacherDao 和 UserDao--");
containerBeans.remove("TeacherDao");
containerBeans.remove("UserDao");
containerBeans.printAllbeanId();
}
}
AspectCachBean：
package com.tgb.config;
/**
* @ClassName: AspectCachBean
* @Description:
* 緩存服務類，實現了對緩存的，前置，后置， 保存的方法
* @author [qmx]
* @date
*
*/
public class AspectCachBean {
/**
*
* @Title: cacheBefore
* @Description: 緩存前置增強方法
* @param @param proxy 代理參數
* @return void 返回類型
* @throws
*/
public void cacheBefore(Object proxy) {
System.out.println("---這是切入 類AspectCachBean cacheBefore()-方法--");
}
/**
*
* @Title: cacheAfter
* @Description: 緩存后置增強方法
* @param @param proxy 返回的代理參數
* @return void 返回類型
* @throws
*/
public static void cacheAfter(Object proxy) {
System.out.println("---這是切入 類AspectCachBean cacheAfter()-方法--");
}
/**
* @Title: cacheSave
* @Description: 緩存保存方法
* @param @param proxy 代理參數
* @return void 返回類型
* @throws
*/
public void cacheSave(Object proxy){
System.out.println("---這是切入 類AspectCachBean cacheSave()-方法--");
}
}
AspectCertifiyBean：
package com.tgb.config;
/**
*
* @ClassName: AspectCertifiyBean
* @Description: 認證服務類，提供了認證前， 認證后，認證保存的方法
* @author [qmx]
* @date
*
*/
public class AspectCertifiyBean {
/**
*
* @Title: certifiyBefore
* @Description: 認證前置增強方法
* @param @param proxy 被代理對象的參數
* @return void 返回類型
* @throws
*/
public void certifiyBefore(Object proxy) {
System.out.println("---這是切入 類AspectCertifiyBean certifiyBefore()-方法--");
}
/**
*
* @Title: certifyAfter
* @Description: 認證后置增強方法
* @param @param proxy 被認證對象參數
* @return void 返回類型
* @throws
*/
public void certifyAfter(Object proxy) {
System.out.println("---這是切入 類AspectCertifiyBean certifyAfter()-方法--");
}
/**
*
* @Title: certifySave
* @Description:認證保存增強方法
* @param @param proxy 被認證對象參數
* @return void 返回類型
* @throws
*/
public void certifySave(Object proxy) {
System.out.println("---這是切入 類AspectCertifiyBean certifySave()-方法--");
}
}
ClassPathXmlApplicationContext：
package com.tgb.config;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeSet;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;
/**
*
* @ClassName: ClassPathXmlApplicationContext
* @Description: 容器組裝類， 裝載 業務容器 和 服務容器。 分別將其中的 顆粒裝載到各自的 beans 中
* 同時提供了對容器的增刪，遍歷等公共方法
* @author [qmx]
* @date
*
*/
public class ClassPathXmlApplicationContext implements ContainerBeans {
// 業務容器beans
private Map<String, Object> businessBeans = new HashMap<String, Object>();
// 公共服務容器beans
private Map<String, Object> aspectBeans = new HashMap<String, Object>();
//關系集合配置
private Map<String, Object> relationBeans = new HashMap<String, Object>();
// 設置是不是需要aop
private boolean isAop = true;
/**
*
* <p>Title: 構造函數 </p>
* <p>Description: 構造函數加載所有配置文件，初始化每一個容器內對象</p>
* @throws Exception
*/
public ClassPathXmlApplicationContext() throws Exception {
SAXBuilder sb = new SAXBuilder();
// 掃描業務文檔，將xml轉為文檔對象
Document businessDoc = sb.build(Thread.currentThread().getContextClassLoader()
.getResourceAsStream("business.xml"));
// 掃描切入文檔，將xml轉為文檔對象
Document aspectDoc = sb.build(Thread.currentThread().getContextClassLoader()
.getResourceAsStream("aspecbeans.xml"));
//掃描關系文檔，將xml轉為文檔對象
Document reliationDoc = sb.build(Thread.currentThread().getContextClassLoader()
.getResourceAsStream("relationbean.xml"));
// 設置切面容器
getAspectBeans(aspectDoc);
// 設置業務容器bean
getBusinessDoc(businessDoc);
//關系集合設置
getRelationBeans(reliationDoc);
}
/***
* 設置業務容器裝配
*
* @param doc
* @throws ClassNotFoundException
* @throws IllegalAccessException
* @throws InstantiationException
* @throws SecurityException
* @throws NoSuchMethodException
* @throws InvocationTargetException
* @throws IllegalArgumentException
*/
private void getBusinessDoc(Document businessDoc) throws InstantiationException,
IllegalAccessException, ClassNotFoundException, NoSuchMethodException,
SecurityException, IllegalArgumentException, InvocationTargetException {
Element root = businessDoc.getRootElement();//讀取文檔根目錄
List list = root.getChildren("bean");
// 調用設備對象方法，裝配業務對象
putAllBeans(list, businessBeans);
}
/**
* 獲得關系集合中 業務容器與切面容器的關系
* @param reliationDoc
*/
private void getRelationBeans(Document reliationDoc) {
Element root = reliationDoc.getRootElement(); //讀取文檔根目錄
Element aopElement = (Element) root.getChildren("aop").get(0); //獲得aop節點信息
isAop = Boolean.parseBoolean(aopElement.getAttributeValue("isaop")); //aop節點屬性
List aopBeforeList = root.getChildren("aspectbefore");// 前置增強節點
List aopAfterList = root.getChildren("aspectafter");//后置增強
//辨別增強節點是不是有配置，放入bean關系容器
if (aopBeforeList != null) {
relationBeans.put("aspectbefore", aopBeforeList);
}
if (aopAfterList != null) {
relationBeans.put("aspectafter", aopAfterList);
}
}
/**
* 設置切入容器裝配對象
*
* @param aspectDoc 切入配置文件
* @throws InstantiationException
* @throws IllegalAccessException
* @throws ClassNotFoundException
* @throws InvocationTargetException
* @throws IllegalArgumentException
* @throws SecurityException
* @throws NoSuchMethodException
*/
private void getAspectBeans(Document aspectDoc) throws InstantiationException,
IllegalAccessException, ClassNotFoundException, NoSuchMethodException,
SecurityException, IllegalArgumentException, InvocationTargetException {
Element root = aspectDoc.getRootElement();
List aspectElements = root.getChildren("aspectbean");// 讀取切入配置文件
putAllBeans(aspectElements, aspectBeans);
}
/**
* 對象裝配方法
*
* @param list
* 讀取的配置文件
* @param allBeans
* 設置裝配的容器對象
* @throws InstantiationException
* @throws IllegalAccessException
* @throws ClassNotFoundException
* @throws NoSuchMethodException
* @throws SecurityException
* @throws IllegalArgumentException
* @throws InvocationTargetException
*/
public void putAllBeans(List list, Map<String, Object> allBeans)
throws InstantiationException, IllegalAccessException,
ClassNotFoundException, NoSuchMethodException, SecurityException,
IllegalArgumentException, InvocationTargetException {
for (int i = 0; i < list.size(); i++) {
//獲得傳入父親節點中的每一個子節點，為行element
Element element = (Element) list.get(i);
//獲得子節點中的id屬性
String id = element.getAttributeValue("id");
//獲得子節點中的class屬性
String clazz = element.getAttributeValue("class");
//實例化class
Object o = Class.forName(clazz).newInstance();
//將實例化的class放入容器
allBeans.put(id, o);
//for循環獲得 bean中的 屬性property
for (Element propertyElement : (List<Element>) element
.getChildren("property")) {
//獲得property屬性中的name屬性
String name = propertyElement.getAttributeValue("name"); // userDAO
//獲得property屬性中的ref屬性
String bean = propertyElement.getAttributeValue("ref"); //
//獲得子屬性的試題
Object beanObject = allBeans.get(bean);// UserDAOImpl
//調用 依賴實體中的set方法（為籽實體的方法）
String methodName = "set" + name.substring(0, 1).toUpperCase()
+ name.substring(1);
// 獲得依賴注入對象的父類，如： userDaoImp 獲得的為祈父類接口 userDao｛eanObject.getClass().getInterfaces()[0]｝
Method m = o.getClass().getMethod(methodName, //若依賴對象沒有父類接口，該方法中的參數需要修改成類本身援用
beanObject.getClass().getInterfaces()[0]);
m.invoke(o, beanObject); //調用o中 set方法，設置注入對象
}
}
}
/**
* 獲得容器中指定對象
*
* @param id
* 對象名稱如： getBean("user")
* @return
*/
public Object getBean(String id) {
//讀取是不是配置aop節點屬性，若是返回aop代理類
if (!isAop) {
return businessBeans.get(id);
}
return new JDKDynamicProxy(businessBeans.get(id), aspectBeans, businessBeans,relationBeans)
.getProxy();
}
/**
* 容器中放入對象
*
* @param k
* @param v
* @return
*/
public Object put(String k, Object v) {
return businessBeans.put(k, v);
}
/**
* 打印容器中所有對象類型
*/
public void printTypeName() {
Set<String> hashSet = new HashSet<String>();
//set集合獲得map中的所有值
Set<Entry<String, Object>> entryset = businessBeans.entrySet();
{
//iterator獲得迭代屬性
Iterator iterator = entryset.iterator();
//while循環獲得每一個值
while (iterator.hasNext()) {
Entry<String, Object> entry = (Entry<String, Object>) iterator.next();
hashSet.add(entry.getValue().getClass().getSimpleName());
}
}
for (String setType : hashSet) {
System.out.println(setType);
}
}
/**
* 獲得容器中所有對象
*
* @return Map<string(對象類型)，Object(對象)>
*/
public Map<String, Object> getAllBean() {
Map<String, Object> beanList = new HashMap<String, Object>();
//獲得得帶屬性
Iterator iterator = businessBeans.entrySet().iterator();
//while循環獲得每一個值
while (iterator.hasNext()) {
Entry<String, Object> entry = (Entry<String, Object>) iterator.next();
beanList.put(entry.getValue().getClass().getSimpleName(), entry.getValue());
}
return beanList;
}
/***
* 刪除指定對象
*/
public void remove(String id) {
businessBeans.remove(id);
}
/***
* 打印所有注入對象
*/
public void printAllbeanId() {
Set<Entry<String, Object>> entryset = businessBeans.entrySet();
Set<String> linkSet = new TreeSet<String>();
{
Iterator iterator = entryset.iterator();
while (iterator.hasNext()) {
Entry<String, Object> entry = (Entry<String, Object>) iterator.next();
linkSet.add(entry.getKey());
// System.out.println(entry.getKey());
}
System.out.println("容器中含有對象是" + this.size() + "個,分別是：");
System.out.println(linkSet.toString());
}
}
/**
* 獲得容器中對象的個數
*/
public int size() {
return businessBeans.size();
}
}
ContainerBeans：
package com.tgb.config;
import java.util.Map;
/**
*
* @ClassName: ContainerBeans
* @Description: 容器接口，提供容器公共服務方法， 增加，刪除，遍歷，獲得對象，遍歷類型，容器大小等方法
* @author [qmx]
* @date
*
*/
public interface ContainerBeans {
/**
* 獲得容器中指定對象
*
* @param id
* 對象名稱如： getBean("user")
* @return
*/
public Object getBean(String id);
/**
* 容器中放入對象
*
* @param k
* @param v
* @return
*/
public Object put(String k, Object v);
/**
* 打印容器中所有對象類型
*/
public void printTypeName();
/**
* 獲得容器中所有對象 返回類型 Map<string(對象類型)，Object(對象)>
* @return Map<string(對象類型)，Object(對象)>
*/
public Map<String, Object> getAllBean();
/**
* 獲得容器所有bean
*/
public void printAllbeanId();
/**
*
* @Title: remove
* @Description: 刪除容器指定對象
* @param @param id 刪除對象的id
* @return void 返回類型
* @throws
*/
public void remove(String id);
/**
* 容器中對象的數量
* @return
*/
public int size();
}
JDKDynamicProxy：
package com.tgb.config;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.jdom.Element;
/**
*
* @ClassName: JDKDynamicProxy
* @Description: AOP實現對業務容器 的增強，對業務容器中每一個對象增強 服務類中的方法，根據 關系容器配置，
* 實現特性方法增強
* @author [qmx]
* @date
*
*/
public class JDKDynamicProxy implements InvocationHandler {
private Object target;//被代理對象
private Map<String, Object> aspectBeans; // 服務容器
private Map<String, Object> businessBeans;// 業務容器
private Map<String, Object> relationBeans;// 關系容器
/***
*
* @param target
* 被代理對象
* @param aspectBeans
* 切容器
* @param businessBeans
* 業務容器
* @param relationBeans
* 關系集合
*/
public JDKDynamicProxy(Object target, Map<String, Object> aspectBeans,
Map<String, Object> businessBeans, Map<String, Object> relationBeans) {
this.target = target;
this.aspectBeans = aspectBeans;
this.businessBeans = businessBeans;
this.relationBeans = relationBeans;
}
/**
* @Title: getProxy
* @Description: 創建被代理對象
* @param @return
* @return T 返回類型 被代理對象 類型
* @throws
*/
@SuppressWarnings("unchecked")
public <T> T getProxy() {
return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target
.getClass().getInterfaces(), this);
}
// 回調注冊切入對象方法
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
List beforeList = (List) relationBeans.get("aspectbefore");// 獲得關系容器中的關系
invokeAspectName(beforeList, method, args);// 調用切面類中匹配方法
Object result = method.invoke(target, args);// 調用 被代理類本身方法
return result;
}
/**
* 攔截方法匹配規則
*
* @param beforeList
* 攔截器的所有對象
* @param method
* @param args
* @throws NoSuchMethodException
* @throws SecurityException
* @throws IllegalAccessException
* @throws IllegalArgumentException
* @throws InvocationTargetException
*/
public void invokeAspectName(List beforeList, Method method, Object[] args)
throws NoSuchMethodException, SecurityException, IllegalAccessException,
IllegalArgumentException, InvocationTargetException {
//判斷關系容器中是不是指定了特性方法攔截，若無，則對 代理對象 履行所有服務類方法增強
if (beforeList != null && beforeList.size() != 0) {
for (int i = 0; i < beforeList.size(); i++) {
Element element = (Element) beforeList.get(i);
String aspectClass = element.getAttributeValue("aspectId");// 獲得容器中切入類名稱
String aspectName = element.getAttributeValue("aspectMethod");// 履行的切入方法
if (aspectBeans.get(aspectClass) == null) {
System.out.println("未找到" + aspectClass + "切入類，請查看配置的切入類名稱是不是正確");
return;
}
Class clazz = aspectBeans.get(aspectClass).getClass(); // 獲得切入類
String elementMethod = element.getAttributeValue("method");// 獲得被切入類方法
//1 關系容器中某個攔截配置，若未聲明履行某個服務類中的方法，則履行所有服務類中方法，
//2 若未指定某個攔截方法，但指定了被攔截對象的方法，則所有服務類只對該方法攔截
//3
if (aspectName == null) {
//聲明了攔截某個對象方法，履行指定方法攔截
if (method.getName() != null) {
if (method.getName().equals(elementMethod)) {
//，履行該服務類中所有方法
getAllMethod(clazz, aspectClass, args);
}
}
//履行所有服務類中的所有方法
aspactAllClass(aspectClass, args == null ? new Object[1] : args);
} else {
// 聲明切入方法，則履行指定切入方法
if (method.getName().equals(elementMethod)) {
Method jinectmethod = clazz.getMethod(aspectName, Object.class); // 反射調用切入類方法
jinectmethod.invoke(aspectBeans.get(aspectClass),
args == null ? new Object[1] : args);
}
aspactAllClass(aspectClass, args == null ? new Object[1] : args);
}
}
} else {
//默許履行所有服務類中的方法增強
Iterator aspectClass = aspectBeans.entrySet().iterator();
while (aspectClass.hasNext()) {
Entry<String, Object> entry = (Entry<String, Object>) aspectClass.next();
Class clazz = entry.getValue().getClass();// 獲得服務類
// 獲得服務類中的所有公共方法
Method[] methods = clazz.getDeclaredMethods();
for (int j = 0; j < methods.length; j++) {
// 反射獲得服務類中每一個方法名稱，獲得該服務類方法
Method jinectmethod = clazz.getMethod(methods[j].getName(),
Object.class);
jinectmethod.invoke(entry.getValue(), args == null ? new Object[1]
: args);
}
}
}
}
/**
*
* @Title: aspactAllClass
* @Description: 除本身，履行其他所有服務類中方法。
* @param @param aspectId
* @param @param args
* @param @throws NoSuchMethodException
* @param @throws SecurityException
* @param @throws IllegalAccessException
* @param @throws IllegalArgumentException
* @param @throws InvocationTargetException 設定文件
* @return void 返回類型
* @throws
*/
public void aspactAllClass(String aspectId, Object[] args)
throws NoSuchMethodException, SecurityException, IllegalAccessException,
IllegalArgumentException, InvocationTargetException {
Iterator aspectClass = aspectBeans.entrySet().iterator();
while (aspectClass.hasNext()) {
Entry<String, Object> entry = (Entry<String, Object>) aspectClass.next();
//
if (!aspectId.equals(entry.getKey())) {
Class clazz = entry.getValue().getClass();// 獲得切入類
Method[] methods = clazz.getDeclaredMethods();
for (int j = 0; j < methods.length; j++) {
// 反射獲得服務類中每一個方法名稱，獲得該服務類方法
Method jinectmethod = clazz.getMethod(methods[j].getName(),
Object.class);
// 反射調用切入類方法
jinectmethod.invoke(entry.getValue(), args == null ? new Object[1]
: args);
}
}
}
}
/**
*
* @Title: getAllMethod
* @Description: 履行某個服務類中的所有方法，
* @param @param clazz 服務類
* @param @param aspectClass aop關系集合中設定履行 攔截的方法
* @param @param args 被攔截對象的參數
* @param @throws IllegalAccessException
* @param @throws IllegalArgumentException
* @param @throws InvocationTargetException
* @param @throws NoSuchMethodException
* @param @throws SecurityException 設定文件
* @return void 返回類型
* @throws
*/
public void getAllMethod(Class clazz, String aspectClass, Object[] args)
throws IllegalAccessException, IllegalArgumentException,
InvocationTargetException, NoSuchMethodException, SecurityException {
// 獲得服務類中的所有公共方法
Method[] methods = clazz.getDeclaredMethods();
for (int j = 0; j < methods.length; j++) {
// 反射獲得服務類中每一個方法名稱，獲得該服務類方法
Method jinectmethod = clazz.getMethod(methods[j].getName(), Object.class);
// 反射調用服務類中方法
jinectmethod.invoke(aspectBeans.get(aspectClass),
args == null ? new Object[1] : args);
}
}
}
StudentDao：
package com.tgb.dao;
/**
* studendao，打印方法
* @ClassName: StudentDao
* @Description: TODO(這里用1句話描寫這個類的作用)
* @author [qmx]
* @date
*
*/
public interface StudentDao {
public void syaName();
}
TeacherDao：
package com.tgb.dao;
import com.tgb.domain.User;
/*
* TeacherDao對象，增加刪除，保存方法
*/
public interface TeacherDao {
void save(User user);
void update(User user);
public void delete( User user);
}
UserDao：
package com.tgb.dao;
import com.tgb.domain.User;
/*
* userdao對象，增加刪除，保存方法
*/
public interface UserDao {
void save(User user);
void update(User user);
public void delete( User user);
}
StudentDaoImpl：
package com.tgb.daoImpl;
import com.tgb.dao.StudentDao;
/*
* StudentDaoImpl對象，打印方法
*/
public class StudentDaoImpl implements StudentDao {
@Override
public void syaName() {
System.out.println("----my name is hanyk--");
}
}
TeacherDaoImpl：
package com.tgb.daoImpl;
import com.tgb.dao.TeacherDao;
import com.tgb.dao.UserDao;
import com.tgb.domain.User;
/*
* TeacherDaoImpl對象，增加刪除，保存方法
*/
public class TeacherDaoImpl implements TeacherDao {
@Override
public void save(User user) {
System.out.println( "這是業務類 "+this.getClass()+"-----的 save()方法-----");
}
@Override
public void update(User user) {
System.out.println( "這是業務類 "+this.getClass()+"-----的 update()方法-----");
}
@Override
public void delete(User user) {
System.out.println( "這是業務類 "+this.getClass()+"-----的 delete()方法-----");
}
}
UserDaoImpl：
package com.tgb.daoImpl;
import com.tgb.dao.UserDao;
import com.tgb.domain.User;
/*
* userdao對象，增加刪除，保存方法
*/
public class UserDaoImpl implements UserDao {
@Override
public void save(User user) {
System.out.println( "這是業務類 "+this.getClass()+"-----的 userDao.save()方法-----");
}
@Override
public void update(User user) {
System.out.println( "這是業務類 "+this.getClass()+"-----的 userDao.update()方法-----");
}
@Override
public void delete(User user) {
System.out.println( "這是業務類 "+this.getClass()+"-----的 userDao.delete()方法-----");
}
}
User：
package com.tgb.domain;
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;
}
}
aspectbeans.xml:
<!--該文件 對是服務類的配置，所有服務類都需要在該文件進行注冊-->
<beans>
<!--服務類配置容器，配置緩存服務類，全名稱 -->
<aspectbean id="aspectCachBean" class="com.tgb.config.AspectCachBean"></aspectbean>
<!-- <aspectbean id="aspectCertifiyBean" class="com.tgb.configra.AspectCertifiyBean"></aspectbean> -->
</beans>
business.xml:
<!--該文件是業務類的配置-->
<beans>
<!--用戶bean注入-->
<bean id="UserDao" class="com.tgb.daoImpl.UserDaoImpl" />
<!--教師bean注入-->
<bean id="TeacherDao" class="com.tgb.daoImpl.TeacherDaoImpl" />
</beans>
relationbean.xml:
<!--aop關系配置文件-->
<beans>
<!-- 是不是啟用aop -->
<aop isaop="true"></aop>
<!-- 配置業務顆粒和服務類的增強關系method為業務類匹配的方法，可用
正則表達式進行（未實現） ，aspectMethod為服務類攔截方法 -->
<aspectbefore aspectId="aspectCachBean" method="update" aspectMethod="cacheSave" ></aspectbefore>
</beans>
生活不易，碼農辛苦
如果您覺得本網站對您的學習有所幫助,可以手機掃描二維碼進行捐贈
