1、概述

Aop:(Aspect Oriented Programming)面向切面编程
          功能: 让关注点代码与业务代码分离!

关注点:重复代码就叫做关注点;
切面: 关注点形成的类,就叫切面(类)!
            面向切面编程,就是指对很多功能都有的重复的代码抽取,再在运行的时候往业务方法上动态植入“切面类代码”。
切入点:执行目标对象方法,动态植入切面代码。
               可以通过切入点表达式,指定拦截哪些类的哪些方法;给指定的类在运行的时候植入切面类代码。

2、XML方式实现AOP编程

2.1、我用到的jar包

    

这些Spring包  不一定每个都使用到

2.2、简单实例演示1(需要实现接口,相当于动态代理)Spring的动态代理:https://www.cnblogs.com/dshore123/p/11753623.html

IUserDao 接口类

 package com.shore.dao;

 /**
* @author DSHORE/2019-11-7
*
*/
public interface IUserDao {
public void save();
}

UserDao 接口的实现类

 package com.shore.dao.impl;

 import com.shore.dao.IUserDao;

 /**
* @author DSHORE/2019-11-7
*
*/
public class UserDao implements IUserDao { @Override
public void save() { //3、执行业务方法
System.out.println("3、保存用户成功!");
}
}

Aop 类(程序执行到某一业务时,先去执行指定逻辑代码)

 package com.shore.aop;

 import org.aspectj.lang.ProceedingJoinPoint;

 /**
* @author DSHORE/2019-11-7
*
*/
public class Aop {
//around:环绕; ProceedingJoinPoint:必须添加(执行)
@SuppressWarnings("unused")
private void around(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("2、环绕前....");
pjp.proceed(); // 执行目标方法(业务代码)
System.out.println("5、环绕后....");
} public void begin() {
System.out.println("1、开启事务......");
} public void commit() {
System.out.println("6、提交事务......");
} public void afterReturning() {
System.out.println("4、afterReturning(),返回消息");
} //有异常,执行这个第四步;没有异常,则执行上面的第四步
public void afterThrowing(){
System.out.println("4、afterThrowing(),返回异常消息");
}
}

Spring 配置文件(beans.xml)     切入点表达式:https://www.cnblogs.com/dshore123/p/11823849.html

 <?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:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- dao类 -->
<bean id="userDao" class="com.shore.dao.impl.UserDao"></bean>
<!-- 注入切面类 -->
<bean id="aop" class="com.shore.aop.Aop"></bean> <aop:config>
<!-- 配置切入点 -->
<aop:pointcut expression="execution(* com.shore.dao.impl.*.*(..))" id="pt" />
<!-- 配置切面(切入点形成的类,切入点就是重复的代码/方法) -->
<aop:aspect ref="aop">
<!-- 1、开启事务。。。。。。 -->
<aop:before method="begin" pointcut-ref="pt" />
<!-- 6、提交事务 -->
<aop:after method="commit" pointcut-ref="pt" />
<!-- 环绕2/5 -->
<aop:around method="around" pointcut-ref="pt" />
<!-- 4、afterReturning -->
<aop:after-returning method="afterReturning"
pointcut-ref="pt" />
<!-- 4、异常(程序出现异常,执行这个第四步;没有异常,则执行上面的第四步) -->
<aop:after-throwing method="afterThrowing"
pointcut-ref="pt" />
</aop:aspect>
</aop:config>
</beans>

测试类

 package com.shore.test;

 import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext; import com.shore.dao.IUserDao; /**
* @author DSHORE/2019-11-7
*
*/
public class MyTest {
@Test
public void testUserDao() {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
IUserDao userDao = (IUserDao) context.getBean("userDao");
//$Proxy4 :class com.sun.proxy.$Proxy4
System.out.println("这个相当于动态代理$Proxy4:"+userDao); //返回值:com.shore.dao.impl.UserDao@73aecc3a
userDao.save();
}
}

测试结果图

2.3、简单实例演示2(不需要实现接口,相当于Cglib子类代理) Spring的Cglib子类代理:https://www.cnblogs.com/dshore123/p/11753623.html

MessageDao 类(没有实现接口)

 package com.shore.dao.impl;

 /**
* @author DSHORE/2019-11-7
*
*/
public class MessageDao {
public void save() { //3、执行业务方法
System.out.println("3、保存信息成功!");
}
}

Aop 类(和上面2.2中的一样,不变)

 package com.shore.aop;

 import org.aspectj.lang.ProceedingJoinPoint;

 /**
* @author DSHORE/2019-11-7
*
*/
public class Aop {
//around:环绕; ProceedingJoinPoint:必须添加(执行)
@SuppressWarnings("unused")
private void around(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("2、环绕前....");
pjp.proceed(); // 执行目标方法(业务代码)
System.out.println("5、环绕后....");
} public void begin() {
System.out.println("1、开启事务......");
} public void commit() {
System.out.println("6、提交事务......");
} public void afterReturning() {
System.out.println("4、afterReturning(),返回消息");
} //有异常,执行这个第四步;没有异常,则执行上面的第四步
public void afterThrowing(){
System.out.println("4、afterThrowing(),返回异常消息");
}
}

Spring 配置文件(beans.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:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- dao类 -->
<!-- <bean id="userDao" class="com.shore.dao.impl.UserDao"></bean> -->
<bean id="messageDao" class="com.shore.dao.impl.MessageDao"></bean>
<!-- 注入切面类 -->
<bean id="aop" class="com.shore.aop.Aop"></bean> <aop:config>
<!-- 配置切入点 -->
<aop:pointcut expression="execution(* com.shore.dao.impl.*.*(..))" id="pt" />
<!-- 配置切面(切入点形成的类,切入点就是重复的代码/方法) -->
<aop:aspect ref="aop">
<!-- 1、开启事务。。。。。。 -->
<aop:before method="begin" pointcut-ref="pt" />
<!-- 6、提交事务 -->
<aop:after method="commit" pointcut-ref="pt" />
<!-- 环绕2/5 -->
<aop:around method="around" pointcut-ref="pt" />
<!-- 4、afterReturning -->
<aop:after-returning method="afterReturning"
pointcut-ref="pt" />
<!-- 4、异常(程序出现异常,执行这个第四步;没有异常,则执行上面的第四步) -->
<aop:after-throwing method="afterThrowing"
pointcut-ref="pt" />
</aop:aspect>
</aop:config>
</beans>

测试类

 @Test
public void testMessageDao() {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
MessageDao messageDao = (MessageDao) context.getBean("messageDao");
System.out.println("这个相当于Cglib子类代理:"+messageDao);//返回值:com.shore.dao.impl.MessageDao@15412e75
messageDao.save();
}

测试结果图

原创作者:DSHORE

作者主页:http://www.cnblogs.com/dshore123/

原文出自:https://www.cnblogs.com/dshore123/p/11813822.html

欢迎转载,转载务必说明出处。(如果本文对您有帮助,可以点击一下右下角的 推荐,或评论,谢谢!

Java进阶知识21 Spring的AOP编程的更多相关文章

  1. Java基础-SSM之Spring的AOP编程

    Java基础-SSM之Spring的AOP编程 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任.   Spring的本质说白了就是动态代理,接下来我们会体验AOP的用法.它是对OOP的 ...

  2. Java进阶知识15 Spring的基础配置详解

    1.SSH各个的职责 Struts2:是web框架(管理jsp.action.actionform等).Hibernate:是ORM框架,处于持久层.Spring:是一个容器框架,用于配置bean,并 ...

  3. Java进阶知识25 Spring与Hibernate整合到一起

    1.概述 1.1.Spring与Hibernate整合关键点 1) Hibernate的SessionFactory对象交给Spring创建.    2) hibernate事务交给spring的声明 ...

  4. Java进阶知识24 Spring的事务管理(事务回滚)

    1.事务控制概述   1.1.编程式事务控制         自己手动控制事务,就叫做编程式事务控制.         Jdbc代码: connection.setAutoCommit(false); ...

  5. Java进阶知识23 Spring对JDBC的支持

    1.最主要的代码 Spring 配置文件(beans.xml) <!-- 连接池 --> <bean id="dataSource" class="co ...

  6. Java进阶知识20 Spring的代理模式

    本文知识点(目录): 1.概念  2.代理模式      2.1.静态代理      2.2.动态代理      2.3.Cglib子类代理 1.概念 1.工厂模式  2. 单例模式 代理(Proxy ...

  7. Java进阶知识17 Spring Bean对象的创建细节和创建方式

    本文知识点(目录): 1.创建细节         1) 对象创建: 单例/多例         2) 什么时候创建?         3)是否延迟创建(懒加载)         4) 创建对象之后, ...

  8. Java进阶知识22 Spring execution 切入点表达式

    1.概述   切入点(execution ):可以对指定的方法进行拦截,从而给指定的类生成代理对象.(拦截谁,就是在谁那里切入指定的程序/方法) 格式: execution(modifiers-pat ...

  9. Java进阶知识18 Spring对象依赖关系的几种写法

    <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.sp ...

随机推荐

  1. ubuntu svn 安装

    deepin@deepin:~$ sudo apt-get install rabbitvcs-rabbitvcs-cli rabbitvcs-core rabbitvcs-gedit rabbitv ...

  2. Windows下Notepad++连接VMWare中的linux,然后无法安装NppFTP

    一.关于Notepad++版本 我的版本是最新版本:Notepad++ v7.7 32bit 版本最好选择32bit的,看别处的说法是官网上有这样的说明: Note that the most of ...

  3. javascript 垃圾回收机制和内存管理

    前言:这是笔者学习之后自己的理解与整理.如果有错误或者疑问的地方,请大家指正,我会持续更新! 垃圾回收机制的原理是找到不再被使用的变量,然后释放其占用的内存,但这个过程不是时时的,因为其开销比较大,所 ...

  4. (二十五)JSP九大内置对象(转)

    --转载自孤傲苍狼博客 一.JSP运行原理 每个JSP 页面在第一次被访问时,WEB容器都会把请求交给JSP引擎(即一个Java程序)去处理.JSP引擎先将JSP翻译成一个_jspServlet(实质 ...

  5. (六)lucene之其他查询方式(组合查询,制定数字范围、指定字符串开头)

    本章使用的是lucene5.3.0 指定数字范围查询 package com.shyroke.test; import java.io.IOException; import java.nio.fil ...

  6. Java BinarySearch

    Java BinarySearch /** * <html> * <body> * <P> Copyright 1994-2018 JasonInternation ...

  7. 漏洞预警 | ThinkPHP 5.x远程命令执行漏洞

    ThinkPHP采用面向对象的开发结构和MVC模式,融合了Struts的思想和TagLib(标签库).RoR的ORM映射和ActiveRecord模式,是一款兼容性高.部署简单的轻量级国产PHP开发框 ...

  8. nodejs入门API之fs模块

    fs模块下的类与FS常量 fs模块下的主要方法 fs的Promise API与FileHandle类 一.fs模块下的类 1.1 fs.Dir:表示目录流的类,由 fs.opendir().fs.op ...

  9. TypeScript入门七:TypeScript的枚举

    关于枚举 数字枚举 字符串枚举 异构枚举 计算的和常量成员 运行时的枚举与反向映射 常量枚举与外部枚举 一.关于枚举 枚举:一个集的枚举是列出某些有穷序列集的所有成员的程序,或者是一种特定类型对象的计 ...

  10. 【转载】Android性能优化之渲染篇

    下面是渲染篇章的学习笔记,欢迎大家一起学习交流! 1)Why Rendering Performance Matters 现在有不少App为了达到很华丽的视觉效果,会需要在界面上层叠很多的视图组件,但 ...