JavaEE（SSM）企业应用实战 chapter08

最新推荐文章于 2024-09-30 11:15:33 发布
最新推荐文章于 2024-09-30 11:15:33 发布
阅读量263 收藏 1
点赞数 9
分类专栏： JavaEE（SSM）企业应用实战 文章标签： java-ee java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43886305/article/details/141676264
版权

一、AOP实现机制

1、JDK动态代理

（1）接口 LoginService
package com.qf.chapter08.demo01;
​
public interface LoginService {
    public void login();
}
（2）接口实现类 LoginServiceImpl
package com.qf.chapter08.demo01;
​
public class LoginServiceImpl implements LoginService {
    public void login() {
        System.out.println("执行login()方法");
    }
}
（3）PerformHandler.java
package com.qf.chapter08.demo01;
​
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
​
public class PerformHandler implements InvocationHandler {
    // 目标对象
    private Object target;
​
    public PerformHandler(Object target) {
        this.target = target;
    }
​
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 增强的方法
        System.out.println("方法开始执行");
        // 执行被代理类的原方法
        Object invoke = method.invoke(target, args);
        // 增强的方法
        System.out.println("方法执行完毕");
        return invoke;
    }
}
（4）测试类 TestPerformHandler
package com.qf.chapter08.demo01;
​
import java.lang.reflect.Proxy;
​
public class TestPerformHandler {
    public static void main(String[] args) {
        LoginService loginService = new LoginServiceImpl();
        PerformHandler performHandler = new PerformHandler(loginService);
        // 创建代理对象
        loginService = (LoginService) Proxy.newProxyInstance(loginService.getClass().getClassLoader(),
                loginService.getClass().getInterfaces(), performHandler);
        loginService.login();
    }
}

2、CGLib动态代理

（1）CglibProxy.java
package com.qf.chapter08.demo01;
​
import java.lang.reflect.Method;
import org.springframework.cglib.proxy.*;
​
public class CglibProxy implements MethodInterceptor {
    private Enhancer enhancer = new Enhancer();
​
    // 生成代理对象的方法
    public Object getProxy(Class clazz) {
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
        return enhancer.create();
    }
​
    // 回调方法
    public Object intercept(Object obj, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("CGLig代理之前");
        Object invoke = methodProxy.invokeSuper(obj, objects);
        System.out.println("CGLig代理之后");
        return invoke;
    }
}
（2）测试类
package com.qf.chapter08.demo01;
​
public class TestCGLlib {
    public static void main(String[] args) {
        CglibProxy cglibProxy = new CglibProxy();
        // 创建代理对象
        LoginServiceImpl userService = (LoginServiceImpl) cglibProxy.getProxy(LoginServiceImpl.class);
        userService.login();
    }
}

二、Spring AOP的开发方法

1、基于XML开发Spring AOP

（1）修改 applicationContext.xml ，引入 AOP 命名空间
<?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:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/aop 
    http://www.springframework.org/schema/aop/spring-aop.xsd">
    
</beans>
（2）创建接口
package com.qf.chapter08.demo02;
​
public interface UserService {
    void insert();
​
    void delete();
​
    void update();
​
    void select();
}
（3）创建接口实现类
package com.qf.chapter08.demo02;

public class UserServiceImpl implements UserService {

	public void insert() {
		System.out.println("添加用户信息");
	}
	
	public void delete() {
		System.out.println("删除用户信息");
	}

	public void update() {
		System.out.println("更新用户信息");
	}

	public void select() {
		System.out.println("查询用户信息");
	}
}
（4）创建通知类
package com.qf.chapter08.demo02;

import org.aspectj.lang.ProceedingJoinPoint;

public class XmlAdvice {
	// 前置通知
	public void before() {
		System.out.println("这是前置通知");
	}

	// 后置通知
	public void afterReturning() {
		System.out.println("这是后置通知(方法不出现异常时调用)");
	}

	// 环绕通知
	public Object around(ProceedingJoinPoint point) throws Throwable {
		System.out.println("这是环绕通知之前的部分!!");
		// 调用目标方法
		Object object = point.proceed();
		System.out.println("这是环绕通知之后的部分!!");
		return object;
	}

	// 异常通知
	public void afterException() {
		System.out.println("异常通知!!");
	}

	// 后置通知
	public void after() {
		System.out.println("这是后置通知!!");
	}
}
（5）修改 applicationContext.xml ，添加 AOP 配置信息
	<!-- 注册Bean -->
	<bean name="userService" class="com.qf.chapter08.demo02.UserServiceImpl" />
	<bean name="xmlAdvice" class="com.qf.chapter08.demo02.XmlAdvice" />
	<!-- 配置Spring AOP --> 
	<aop:config> 
		<!-- 指定切点 --> 
		<aop:pointcut id="pointcut" expression="execution(* com.qf.chapter08.demo02.UserServiceImpl.*(..))"/> 
		<!-- 指定切面 -->
		<aop:aspect ref="xmlAdvice"> 
			<!-- 指定前置通知 -->
			<aop:before method="before" pointcut-ref="pointcut"/>
			<!-- 指定返回通知 -->
			<aop:after-returning method="afterReturning" pointcut-ref="pointcut"/> 
			<!-- 指定环绕方式 --> 
			<aop:around method="around" pointcut-ref="pointcut" /> 
			<!-- 指定异常通知 --> 
			<aop:after-throwing method="afterException" pointcut-ref="pointcut" /> 
			<!-- 指定后置通知 --> 
			<aop:after method="after" pointcut-ref="pointcut" /> 
		</aop:aspect> 
	</aop:config>
（6）测试类 TestXml
package com.qf.chapter08.demo02;

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

public class TestXml {
	public static void main(String[] args) {
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		UserService userService = context.getBean("userService", UserService.class);
		userService.delete();
	}
}

2、基于注解开发Spring AOP

（1）创建类 AnnoAdvice.java
package com.qf.chapter08.demo02;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;

@Aspect
public class AnnoAdvice {
	// 切点
	@Pointcut("execution(* com.qf.chapter08.demo02.UserServiceImpl.*(..))")
	public void pointcut() {
	}

	// 前置通知
	@Before("pointcut()")
	public void before() {
		System.out.println("这是前置通知");
	}

	// 后置通知
	@AfterReturning("pointcut()")
	public void afterReturning() {
		System.out.println("这是后置通知(方法不出现异常时调用)");
	}

	// 环绕通知
	@Around("pointcut()")
	public Object around(ProceedingJoinPoint point) throws Throwable {
		System.out.println("这是环绕通知之前的部分!!");
		// 调用目标方法
		Object object = point.proceed();
		System.out.println("这是环绕通知之后的部分!!");
		return object;
	}

	// 异常通知
	@AfterThrowing("pointcut()")
	public void afterException() {
		System.out.println("异常通知!!");
	}

	// 后置通知
	@After("pointcut()")
	public void after() {
		System.out.println("这是后置通知!!");
	}
}
（2）修改 applicationContext.xml ，beans 标签内容替换为
	<!-- 注册Bean -->
	<bean name="userService" class="com.qf.chapter08.demo02.UserServiceImpl" /> 
	<bean name="annoAdvice" class="com.qf.chapter08.demo02.AnnoAdvice" /> 
	<!-- 开启@aspectj的自动代理支持 -->
	<aop:aspectj-autoproxy />
（4）测试类 TestAnnotation
package com.qf.chapter08.demo02;

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

public class TestAnnotation {
	public static void main(String[] args) {
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		UserService userService = context.getBean("userService", UserService.class);
		userService.insert();
	}
}

三、Spring AOP的应用

1、性能监控

（1）Services01.java
package com.qf.chapter08.demo03;

public class Service01 {
	public void service() throws Exception {
		System.out.println("执行service()方法");
		Thread.sleep(1000);
	}
}
（2）Record.java
package com.qf.chapter08.demo03;

import java.util.Date;

public class Record {
	private String className; // 类名称
	private String methodName; // 方法名称
	private Date recordTime; // 记录时间
	private Long expendTime; // 程序执行耗费的时间

	public String getClassName() {
		return className;
	}

	public void setClassName(String className) {
		this.className = className;
	}

	public String getMethodName() {
		return methodName;
	}

	public void setMethodName(String methodName) {
		this.methodName = methodName;
	}

	public Date getRecordTime() {
		return recordTime;
	}

	public void setRecordTime(Date recordTime) {
		this.recordTime = recordTime;
	}

	public Long getExpendTime() {
		return expendTime;
	}

	public void setExpendTime(Long expendTime) {
		this.expendTime = expendTime;
	}

	@Override
	public String toString() {
		return "Record [className=" + className + ", methodName=" + methodName + ", recordTime=" + recordTime
				+ ", expendTime=" + expendTime + "]";
	}
}
（3）RecordAspect.java
package com.qf.chapter08.demo03;

import java.util.Date;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;

@Aspect
public class RecordAspect {
	@Pointcut("execution(* com.qf.chapter08.demo03.Service*.*(..))")
	public void record() {
	}

	@Around("record()")
	public Object recordTimer(ProceedingJoinPoint thisJoinPoint) throws Throwable {
		// 获取目标对象的类名称
		String clazzName = thisJoinPoint.getTarget().getClass().getName();
		// 获取目标对象的方法名称
		String methodName = thisJoinPoint.getSignature().getName();
		// 计算目标对象对应方法执行所耗时间
		long startTime = System.currentTimeMillis();
		Object result = thisJoinPoint.proceed();
		long time = System.currentTimeMillis() - startTime;
		Record record = new Record();
		record.setExpendTime(time); // 记录执行所耗时间
		record.setClassName(clazzName); // 记录类名称
		record.setMethodName(methodName); // 记录对应方法名称
		record.setRecordTime(new Date()); // 记录时间
		System.out.println(record.toString());
		return result;
	}
}
（4）applicationContext_record.xml

resources目录下新建chapter08目录，在chapter08目录下新建

<?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:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/aop 
    http://www.springframework.org/schema/aop/spring-aop.xsd">
    
	<bean name="service01" class="com.qf.chapter08.demo03.Service01" />
	<bean name="recordAspect" class="com.qf.chapter08.demo03.RecordAspect" />
	<aop:aspectj-autoproxy />

</beans>
（5）测试类 TestRecord.java
package com.qf.chapter08.demo03;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.qf.chapter08.demo03.Service01;

public class TestRecord {
	public static void main(String[] args) throws Exception {
		ApplicationContext context = new ClassPathXmlApplicationContext("chapter08/applicationContext_record.xml");
		Service01 service01 = context.getBean("service01", Service01.class);
		service01.service();
	}
}

2、异常监控

（1）自定义异常类
package com.qf.chapter08.demo03;

public class MyException extends Exception {
	private static final long serialVersionUID = 1L;
	private String msg;

	public MyException(String msg) {
		super();
		this.msg = msg;
	}

	public String getMsg() {
		return msg;
	}
}
（2）Services02.java
package com.qf.chapter08.demo03;

public class Service02 {
	public void service() throws Exception {
		System.out.println("执行service()方法");
		int num = 105;
		if (num > 100 || num < 0) {
			throw new MyException("您输入的不正确，请输入0--100之间的数字");
		} else {
			System.out.println("您输入的数字是" + num);
		}
	}
}
（3）Message.java
package com.qf.chapter08.demo03;

import java.util.Date;

public class Message {
	private String className;
	private String methodName;
	private Date recordTime; // 异常记录时间
	private String exceptionMsg; // 异常信息

	public String getClassName() {
		return className;
	}

	public void setClassName(String className) {
		this.className = className;
	}

	public String getMethodName() {
		return methodName;
	}

	public void setMethodName(String methodName) {
		this.methodName = methodName;
	}

	public Date getRecordTime() {
		return recordTime;
	}

	public void setRecordTime(Date recordTime) {
		this.recordTime = recordTime;
	}

	public String getExceptionMsg() {
		return exceptionMsg;
	}

	public void setExceptionMsg(String exceptionMsg) {
		this.exceptionMsg = exceptionMsg;
	}

	@Override
	public String toString() {
		return "Message [className=" + className + ", " + "methodName=" + methodName + ", recordTime=" + recordTime
				+ ", exceptionMsg=" + exceptionMsg + "]";
	}
}
（4）MessageAspect.java
package com.qf.chapter08.demo03;

import java.util.Date;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;

@Aspect
public class MessageAspect {
	@Pointcut("execution(* com.qf.chapter08.demo03.Service*.*(..))")
	public void exceptionMsg() {
	}

	@Around("exceptionMsg()")
	public Object msgMethod(ProceedingJoinPoint thisJoinPoint) throws Throwable {
		// 获取目标对象的类名称
		String clazzName = thisJoinPoint.getTarget().getClass().getName();
		// 获取目标对象的方法名称
		String methodName = thisJoinPoint.getSignature().getName();
		try {
			return thisJoinPoint.proceed();
		} catch (MyException e) {
			Message msg = new Message();
			// 封装异常信息
			msg.setClassName(thisJoinPoint.getTarget().getClass().getName());
			msg.setMethodName(thisJoinPoint.getSignature().getName());
			msg.setRecordTime(new Date());
			msg.setExceptionMsg(e.getMsg());
			System.out.println(msg.toString());
			return null;
		}
	}
}
（5）applicationContext_msg.xml

在chapter08目录下新建

<?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:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/aop 
    http://www.springframework.org/schema/aop/spring-aop.xsd">
    
	<bean name="service01" class="com.qf.chapter08.demo03.Service01" />
	<bean name="recordAspect" class="com.qf.chapter08.demo03.RecordAspect" />
	<aop:aspectj-autoproxy />
	<bean name="service02" class="com.qf.chapter08.demo03.Service02"/>
   <bean name="messageAspect"  class="com.qf.chapter08.demo03.MessageAspect"/>
   <aop:aspectj-autoproxy/>
	
</beans>
（5）测试类 TestMessage.java
package com.qf.chapter08.demo03;

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

public class TestMessage {
	public static void main(String[] args) throws Exception {
		ApplicationContext context = new ClassPathXmlApplicationContext("chapter08/applicationContext_msg.xml");
		Service02 service02 = context.getBean("service02", Service02.class);
		service02.service();
	}
}

千锋-Arther
关注
专栏目录
轻量级JavaEE企业应用实战第5版 代码光盘
07-10
轻量级JavaEE企业应用实战第5版 代码光盘
轻量级JavaEE企业应用实战（第4版）
07-22
资源名称：轻量级Java EE企业应用实战 （第4版）资源目录：第1章　Java EE应用和开发环境 11.1　Java EE应用概述 21.1.1　Java EE应用的分层模型 21.1.2　Java EE应用的组件 31.1.3　Java EE应用的结构和优势 41.1.4...
JavaEE（SSM）企业应用实战 chapter01
weixin_43886305的博客
08-26 511
MyBatis项目搭建，简单应用
JavaEE（SSM）企业应用实战 chapter04
weixin_43886305的博客
09-06 299
MyBatis动态SQL、注解
JavaEE（SSM）企业应用实战 chapter03
weixin_43886305的博客
08-26 294
MyBatis关系映射简单案例
JavaEE（SSM）企业应用实战 chapter07
weixin_43886305的博客
08-29 252
依赖注入，Bean的配置，注解的应用
JavaEE（SSM）企业应用实战 chapter06
weixin_43886305的博客
08-27 174
spring配置，spring简单应用
JavaEE企业级应用开发教程实验十二SSM框架整合
Annzz123的博客
06-15 2001
在src\mian\java\com\sun\config文件夹中创建 ServletContatinerslnitConfig类。在src\mian\java\com\sun\config文件夹中创建 SpringMvcConfig类。在src\mian\java\com\sun\config文件夹中创建MyBatisConfig类。在src\mian\java\com\sun\config文件夹中创建 SpringConfig类。
JavaEE企业级应用开发教程 传智课后题答案
热门推荐
qq_43096468的博客
06-21 1万+
JavaEE企业级应用开发教程 传智课后题答案第一章（Spring的基本应用）第二章（Spring中的Bean）第三章（3-1）（Spring AOP）第三章（3-2）(Spring AOP)第四章（Spring的数据库开发）第五章（Spring的事务管理）第六章（初始MyBatis）第七章（MyBatis的核心配置）第八章（动态SQL）第九章（MyBatis的关联映射）第十章（Spring与MyBatis整合）第十一章（Spring MVC入门）第十二章（Spring MVC的核心类和注解）第十三章（数据
JavaEE企业级应用开发教程——第十章 初识Spring MVC框架（黑马程序员第二版）（SSM）
m0_62096596的博客
04-11 3055
JavaEE企业级应用开发教程——第十章 初识Spring MVC框架（黑马程序员第二版）（SSM）
JavaEE全套资料+视频+工具
u011771858的博客
11-14 5593
JavaEE全套资料+视频+工具 &amp;amp;nbsp; &amp;amp;nbsp; Java学习路线图引言： 一、Java学习路线图—流程篇： 二、Java学习路线图—视频篇： &amp;amp;nbsp; &amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;1、第一阶段-Java基础入门 &amp
轻量级JavaEE企业应用实战（第3版）
07-22
资源名称：轻量级Java EE企业应用实战（第3版）内容简介：本书是《轻量级JavaEE企业应用实战》的第3版，第3版保持了第2版内容全面、深入的特点，主要完成全部知识的升级。本书介绍了JavaEE领域的三个开源框架：...
轻量级JavaEE企业应用实战第三版、第四版书籍及第四版源码
11-08
轻量级JavaEE企业应用实战第三版、第四版书籍及第四版源码，如果资源失效，请联系QQ：497630817
《轻量级JavaEE企业应用实战》配套资源第五版
07-03
《轻量级JavaEE企业应用实战》是一本深入讲解如何使用Struts 2、Spring 3和Hibernate进行整合开发的权威书籍。第五版的配套资源提供了详细的源代码，旨在帮助读者更好地理解和实践书中所讲的技术。尽管源码中不包含...
【JavaEE初阶】深入理解wait和notify以及线程饿死的解决
GGBond778的博客
09-28 1291
本期讲解了关于wait的使用方法，对应的notify的操作，以及线程饿死的场景演示；当然还有在使用wait和notify时的使用注意事项，还附上了对应代码供uu们参考参考
基于J2EE技术的高校社团综合服务系统
最新发布
abo2022的博客
09-30 936
jdk版本:jdk1.8+编程语言: java框架支持：springboot/ssm/springcloud分布式微服务数据库: mysql 版本不限数据库工具：Navicat/SQLyog都可以前端：vue.js+ElementUI开发工具：IDEA 或者eclipse都支持技术范围：SpringBoot、Vue、SSM、HLMT、Jsp、PHP、Nodejs、Python、爬虫、数据可视化、小程序、安卓app、大数据、物联网、机器学习等设计与开发。Java。
【JavaEE】——线程池大总结
2301_80133875的博客
09-27 1701
线程数量问题解决方式，代码实现线程池，ThreadPoolExecutor（核心构造方法），参数的解释（面试：拒绝策略），Executors，工厂模式，工厂类
【JavaEE】——CAS指令和ABA问题
2301_80133875的博客
09-29 1317
CAS指令，伪代码，原子类，CAS中ABA问题，CAS底层分析
SSM框架整合教程 - JavaEE企业级应用开发
SSM框架整合是JavaEE企业级应用开发中常见的技术栈，由Spring、SpringMVC和MyBatis三个框架组成。Spring作为一个全面的框架，提供了依赖注入和面向切面编程等功能；SpringMVC则是Spring框架的一部分，用于处理Web...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值