基于Spring和AOP的数据库认证日志的设计与实现
SpringBoot使用SpringAOP实现日志审计等功能
SpringBoot使⽤SpringAOP实现⽇志审计等功能项⽬当中需要对⽤户操作菜单的⾏为记录⽇志,⽤SpringAOP写了个⼤概实现,切点是采⽤注解的⽅式,⽤包名的⽅式虽然也可以达到相同的效果,但是不如注解⽅式灵活⽅便。
不多说,直接上代码,此处只是简单写写实现原理。
⼯程⽬录:pom.xml引⼊以下依赖:<!-- 热部署模块 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId><scope>runtime</scope><optional>true</optional><!-- 这个需要为 true 热部署才有效 --></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><!-- spring-boot aop依赖配置引⼊ --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId></dependency>注解:@Target({ElementType.METHOD, ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)@Documented@Inheritedpublic @interface Action {String description() default "no description";}Controller类:/*** @auther: gaopeng*/@RestControllerpublic class AspectController {/*** ⾛切⾯* @return*/@GetMapping("/test")@Action(description = "执⾏了test操作菜单")public String test(){return "method return";}/*** 不⾛切⾯*/@GetMapping("/test1")private void test1(){}/*** ⾛切⾯,抛异常*/@GetMapping("/throws")@Action(description = "执⾏了throws菜单但是抛了异常")public void throwsException(){throw new RuntimeException();}}切⾯类:/*** @auther: gaopeng*/@Aspect@Componentpublic class TestAspect {/*** 切⼊点*/// 此处的切点是注解的⽅式,也可以⽤包名的⽅式达到相同的效果//@Pointcut("execution(public * com.gaopeng.springboot.mytest.controller.*.*(..))")@Pointcut("@annotation(com.gaopeng.springboot.mytest.annotation.Action)")public void execute(){}/*** 前置通知* @param joinPoint*/@Before(value ="execute()")public void Before(JoinPoint joinPoint) {System.out.println("执⾏⽅法之前");}/*** 环绕通知* @param proceedingJoinPoint* @return*/@Around(value ="execute()")public Object around(ProceedingJoinPoint proceedingJoinPoint) {System.out.println("环绕通知开始");try {System.out.println("执⾏⽅法:" + proceedingJoinPoint.getSignature().getName()); MethodSignature signature =(MethodSignature) proceedingJoinPoint.getSignature(); Action action = signature.getMethod().getAnnotation(Action.class);System.out.println("菜单="+action.description());Object object = proceedingJoinPoint.proceed();System.out.println("环绕通知结束,⽅法返回:" + object);return object;} catch (Throwable e) {System.out.println("执⾏⽅法异常:" + e.getClass().getName());return null;}}/*** 后置通知* @param joinPoint*/@After(value ="execute()")public void After(JoinPoint joinPoint) {System.out.println("执⾏⽅法之后");}/*** 后置通知,带返回值* @param obj*/@AfterReturning(pointcut = "execute()",returning = "obj")public void AfterReturning(Object obj) {System.out.println("执⾏⽅法之后获取返回值:"+obj);}/*** 后置通知,异常时执⾏* @param e*/@AfterThrowing(throwing = "e",pointcut = "execute()")public void doAfterThrowing(Exception e) {System.out.println("执⾏⽅法异常:"+e.getClass().getName());}}运⾏结果:。
Spring Boot框架中的应用监控与日志管理
Spring Boot框架中的应用监控与日志管理Spring Boot框架是一款基于Spring框架的微服务构建工具,它简化了Spring应用程序的开发过程,并集成了许多常用的功能模块。
其中,应用监控与日志管理是Spring Boot框架中非常重要的功能之一,它能够帮助开发人员实时监控应用的运行状态,及时发现和解决问题,并记录应用的运行日志以便后续分析和排查问题。
本文将深入探讨Spring Boot框架中应用监控与日志管理的相关内容,包括具体功能、实现原理以及最佳实践。
应用监控是保证应用高可用性和高性能的关键手段之一。
Spring Boot框架提供了丰富的监控功能,包括健康检查、性能指标、HTTP追踪等。
其中,健康检查是最为基础和重要的监控功能,通过访问/actuator/health端点,可以获取当前应用的健康状态。
Spring Boot框架默认集成了很多自动配置的健康检查项,包括数据库连接、磁盘空间、线程池状态等。
除此之外,开发人员还可以扩展自定义的健康检查项,比如检查外部服务的可用性。
性能指标是另一个重要的监控功能,Spring Boot框架通过Micrometer库提供了丰富的性能指标支持,包括内存使用、CPU负载、请求处理时间等。
借助这些性能指标,开发人员可以实时监控应用的性能表现,并做出相应的调优优化。
日志管理是应用监控的重要组成部分,它记录了应用运行过程中产生的各种信息,包括调试信息、错误信息、警告信息等。
Spring Boot框架提供了强大的日志管理功能,基于Logback库实现了灵活的日志配置和强大的日志输出。
开发人员可以通过application.properties或application.yml文件,配置日志级别、日志输出目标、日志格式等参数,满足不同环境下的日志记录需求。
同时,Spring Boot框架还提供了统一的日志输出接口,开发人员可以通过Log接口进行日志输出,而无需关心具体的日志实现。
SpringAOP的原理和应用场景
SpringAOP的原理和应用场景SpringAOP(Aspect-Oriented Programming)是Spring框架中的一个重要组成部分,它提供了一种通过预定义的方式,将横切关注点(Cross-cutting Concerns)与业务逻辑进行解耦的机制。
本文将介绍SpringAOP的原理及其在实际应用场景中的应用。
一、SpringAOP的原理SpringAOP基于代理模式(Proxy Pattern)实现。
在SpringAOP中,通过生成与原始类(被代理类)具有相同接口的代理类,将横切逻辑编织到业务逻辑中。
在运行时,当调用代理类的方法时,会在方法执行前、后或异常抛出时插入相应的横切逻辑代码。
具体而言,SpringAOP使用了以下几个核心概念:1. 切面(Aspect):切面是横切逻辑的模块化单元,它包含了一组通知(Advice)和切点(Pointcut)。
2. 通知(Advice):通知定义了实际的横切逻辑代码,并规定了何时执行该代码。
SpringAOP提供了五种类型的通知:前置通知(Before)、后置通知(After)、返回通知(After-returning)、异常通知(After-throwing)和环绕通知(Around)。
3. 切点(Pointcut):切点指定了在哪些连接点(Join Point)上执行通知。
连接点可以是方法调用、属性访问等程序执行的点。
4. 连接点(Join Point):连接点是程序执行过程中的一个特定点,如方法调用前、方法调用后等。
通知通过切点来选择连接点。
5. 织入(Weaving):织入是将切面应用到目标对象,并创建代理对象的过程。
织入可以在编译时、类加载时或运行时进行。
二、SpringAOP的应用场景SpringAOP可应用于各种场景,用于解决跨越多个模块或类的横切关注点问题。
以下是一些常见的SpringAOP应用场景:1. 日志记录:通过在关键方法的前后插入日志代码,实现对系统运行状态的监控和记录。
SpringAOP示例与实现原理总结——传统springaop、基于切面注入、基于@Asp。。。
SpringAOP⽰例与实现原理总结——传统springaop、基于切⾯注⼊、基于@Asp。
⼀、代码实践1)经典的Spring Aop经典的spring aop,是基于动态代理技术的。
实现⽅式上,最常⽤的是实现MethodInterceptor接⼝来提供环绕通知,创建若⼲代理,然后使⽤ProxyBeanFactory配置⼯⼚bean,⽣成拦截器链,完成拦截。
⽰例如下:1package demo.spring;23import org.aopalliance.intercept.MethodInterceptor;4import org.aopalliance.intercept.MethodInvocation;5import org.junit.Test;6import org.junit.runner.RunWith;7import org.springframework.beans.factory.annotation.Autowired;8import org.springframework.test.context.ContextConfiguration;9import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;1011 @RunWith(SpringJUnit4ClassRunner.class)12 @ContextConfiguration("classpath:spring-config.xml")13public class TraditionalSpringAopDemo {14 @Autowired15private Service proxy;1617 @Test18public void test() {19 proxy.execute("hello world!");20 }21 }2223interface Service {24void execute(String str);25 }2627class ServiceImpl implements Service {28 @Override29public void execute(String str) {30 System.out.println("execute invoke: " + str);31 }32 }3334class Interceptor1 implements MethodInterceptor {35 @Override36public Object invoke(MethodInvocation methodInvocation) throws Throwable {37 System.out.println("interceptor1,before invoke");38 Object ret = methodInvocation.proceed();39 System.out.println("interceptor1,after invoke");40return ret;41 }42 }4344class Interceptor2 implements MethodInterceptor {45 @Override46public Object invoke(MethodInvocation methodInvocation) throws Throwable {47 System.out.println("interceptor2,before invoke");48 Object ret = methodInvocation.proceed();49 System.out.println("interceptor2,after invoke");50return ret;51 }52 }xml⽂件配置:1<?xml version="1.0" encoding="UTF-8"?>2<beans xmlns="/schema/beans"3 xmlns:xsi="/2001/XMLSchema-instance"4 xmlns:context="/schema/context"5 xmlns:aop="/schema/aop"6 xsi:schemaLocation="/schema/beans /schema/beans/spring-beans.xsd /schema/context /schema/context/sprin 78<context:component-scan base-package="demo.spring"/>910<bean class="demo.spring.ServiceImpl" id="service"></bean>11<bean class="demo.spring.Interceptor1" id="interceptor1"></bean>12<bean class="demo.spring.Interceptor2" id="interceptor2"></bean>13<bean class="org.springframework.aop.framework.ProxyFactoryBean" id="proxy">14<property name="target" ref="service"/>15<property name="interceptorNames">16<list>17<value>interceptor1</value>18<value>interceptor2</value>19</list>20</property>21</bean>22</beans>结果:interceptor1,before invokeinterceptor2,before invokeexecute invoke: hello world!interceptor2,after invokeinterceptor1,after invoke可以看到拦截链的执⾏过程与拦截器顺序的关系。
基于Annotation的Spring AOP日志处理的设计与实现
Value Engineering0引言AOP (Aspect Oriented Programming ,向切面编程)是建立在OOP (Object Oriented Programming ,面向对象程序设计)基础之上的,OOP 针对问题领域中以及业务处理过程中存在的实体及其属性和操作进行抽象和封装,面向对象的核心概念是纵向结构的,其目的是获得更加清晰高效的逻辑单元划分;而AOP 则是针对业务处理过程中的切面进行提取,例如,某一个操作(例如日志输出)在各个模块中都有涉及,这个操作就可以看成“横切”存在于系统当中。
在许多情况下,这些操作都是与业务逻辑相关性不强或者不属于逻辑操作的必须部分,而面向对象的方法很难对这种情况做出处理。
AOP 则将这些操作与业务逻辑分离,使程序员在编写程序时可以专注于业务逻辑的处理,而利用AOP 将贯穿于各个模块间的横切关注点自动耦合进来[1]。
AOP 被定义为一种编程技术,用来在系统中提升业务的分离,它将服务模块化,使得业务层完全没必要理会这些服务的存在,比如日志,事务,安全等。
1Spring AOP 的Annotation 方式的技术要点1.1Annotation 技术sun 公司从J2SE 5.0开始提供名为Annotation (注释)的功能,它被定义为JSR-175规范[2],是Java 语言中的一种特殊的元数据语法,可以被添加到Java 代码中。
类,方法,变量,参数,包都可以被标注。
Annotation 是可以被反射的,因为它们被编译器生成嵌入在编译后文件,并保留在虚拟机中以便在运行时被索引[3]。
注释是以“@注释名”在代码中存在,一般只有一行,也可以包含有任意的参数。
从Spring2.0以后的版本中,集成了AspectJ 注解。
AOP 的实现有多种方式,使用Annotation 方式的配置,无需配置文件,只需要通过添加“注释代码”来完成,简化了Spring 的开发,容易对方法进行拦截。
基于SpringBootAdminLTE3的博客管理系统设计与实现
1、用户管理:包括用户注册、 登录、信息修改等功能。
2、博客管理:包括文章创建、编辑、发布、删除等功能,同时支持文章分类。
3、评论管理:允许用户对博客文章进行评论,管理员可以删除或置顶评论。
4、标签管理:为博客文章添加标签,方便用户浏览相关文章。
5、统计功能:统计博客访问量、评论数等数据,以可视化图表展示。
在部署方面,我们采用了Docker容器化技术,将应用程序打包成Docker镜像, 并使用Docker Compose进行容器编排。通过这种方式,我们可以快速部署和 扩展系统,以满足不同规模的应用需求。
通过基于Spring Boot AdminLTE3的博客管理系统设计与实现,我们成功地构 建了一个功能完善、易于维护的博客平台。该平台具有高度的可扩展性和可定 制性,可以根据实际需求进行二次开发和扩展。该平台具有良好的用户体验和 数据可视化效果,使得用户和管理员能够更加方便地进行信息交互和管理操作。
展望未来,我们将继续对该系统进行优化和改进。计划包括加强安全性措施、 引入算法提升文章推荐准确性、支持多语言翻译等扩展功能。我们也希望能够 吸引更多的开发者加入到这个项目中来,共同完善和优化这个博客管理系统, 为互联网用户提供更好的服务。
谢谢观看
在实现中,我们使用了AdminLTE的布局、组件和插件,如Sidebar、Navbar、 Grid等。同时,通过自定义CSS样式和JavaScript脚本,实现了评论、标签等 功能的动态展示和交互效果。此外,我们还利用ECharts等可视化库实现了数 据统计图表的展示。
我们对系统进行了详细的测试,包括单元测试、集成测试和功能测试等。通过 测试,我们发现并解决了一些潜在的问题和缺陷,确保系统的稳定性和可靠性。
Hale Waihona Puke 本系统基于Spring Boot框架进行开发,充分利用了Spring Boot的自动化配 置和轻量级开发的优势。我们使用Spring Data JPA作为数据持久层,使得数 据库操作更加便捷。此外,系统还集成了AdminLTE3前端框架,以提供美观、 易用的用户界面。
spring的意思
spring的意思Spring的意思Spring是一种开源的、轻量级的、全栈的Java应用开发框架。
它是基于IoC(Inversion of Control)和AOP(Aspect-Oriented Programming)的编程模型,旨在简化企业级应用程序的开发。
首先,Spring的“意思”可以从字面上理解为春天的意思。
春天象征着新生、希望与活力。
同样,Spring框架为Java应用程序注入了新的活力与创造力,使得开发人员能够更加轻松地构建高效、可靠的应用程序。
Spring框架的核心特点是IoC和AOP:1. IoC(Inversion of Control):传统的编程模型中,应用程序的各个组件之间通常直接进行耦合。
而Spring采用IoC容器,将对象的依赖关系交由容器进行管理,通过配置文件或注解将对象之间的依赖关系进行解耦。
开发者只需关注业务逻辑的实现,而无需关心对象的创建和销毁,大大简化了开发流程。
2. AOP(Aspect-Oriented Programming):AOP是一种编程范式,与IoC相辅相成。
通过AOP,开发者可以将一些与业务逻辑无关但又需要在多个对象中复用的功能(如日志记录、性能监测等)进行横向抽取,并通过切面(Aspect)的方式进行集中管理。
Spring框架提供了强大的AOP支持,能够在不修改原有代码的情况下,动态地向程序中插入额外的功能。
Spring框架的设计理念是“面向接口编程”,它鼓励开发者通过接口定义业务逻辑,借助IoC容器将不同的实现进行组装。
这种松耦合的设计方式使得应用程序更加灵活、易于维护和扩展。
除了IoC和AOP,Spring框架还提供了许多其他功能和模块,方便开发者构建各种不同类型的应用程序:1. 数据访问层:Spring提供了对各种数据访问技术的支持,包括JDBC、ORM(如Hibernate)、NoSQL数据库等。
通过Spring的事务管理,开发者可以轻松地控制数据库事务,确保数据一致性。
SpringAOP切面日志Demo配置文件方式与注解方式
SpringAOP切⾯⽇志Demo配置⽂件⽅式与注解⽅式⼀、配置⽂件⽅式1、配置applicationContext.xml,<bean id="logAopBean"class="mon.aop.LogAop"></bean><aop:config><aop:aspect id="logAspect"ref="logAopBean"><aop:pointcut expression="execution(* com.demo..*(..))" id="allMethod"/><aop:before method="before" pointcut-ref="allMethod" /><aop:after-throwing method="afterThrowing" pointcut-ref="allMethod" /><aop:after-returning method="afterReturn" pointcut-ref="allMethod" /><aop:after method="after" pointcut-ref="allMethod" /></aop:aspect></aop:config>2、⽇志处理类,/*** LogAop.java** Shanghai NTT DATA Synergy Software Co., Ltd. All Rights Reserved.* @author wyl* @date 2016-10-18*/package mon.aop;import ng.JoinPoint;import ng.ProceedingJoinPoint;/*** @author wyl* @Description TODO* @date 2016-10-18**/public class LogAop {public void before(JoinPoint call){String className = call.getTarget().getClass().getName();String methodName = call.getSignature().getName();System.out.println("开始执⾏:"+className+"."+methodName+"()⽅法...");}public void afterThrowing(JoinPoint call){String className = call.getTarget().getClass().getName();String methodName = call.getSignature().getName();System.out.println(className+"."+methodName+"()⽅法抛出了异常...");}public void afterReturn(JoinPoint call){String className = call.getTarget().getClass().getName();String methodName = call.getSignature().getName();System.out.println(className+"."+methodName+"()⽅法正常执⾏结束...");}public void after(JoinPoint call){String className = call.getTarget().getClass().getName();String methodName = call.getSignature().getName();System.out.println(className+"."+methodName+"()最终执⾏步骤(finally)...");}/*//⽤来做环绕通知的⽅法可以第⼀个参数定义为ng.ProceedingJoinPoint类型public Object doAround(ProceedingJoinPoint call) throws Throwable {Object result = null;this.before(call);//相当于前置通知try {result = call.proceed();this.afterReturn(call); //相当于后置通知} catch (Throwable e) {this.afterThrowing(call); //相当于异常抛出后通知throw e;}finally{this.after(call); //相当于最终通知}return result;}*/}⼆、注解⽅式1、配置applicationContext.xml,<bean id="logAspectBean"class="mon.aop.LogAnnotationAspect"></bean> <aop:aspectj-autoproxy/>2、⽇志处理类,/*** LogAnnotationAspect.java** Shanghai NTT DATA Synergy Software Co., Ltd. All Rights Reserved.* @author wyl* @date 2016-10-18*/package mon.aop;import ng.JoinPoint;import ng.ProceedingJoinPoint;import ng.annotation.After;import ng.annotation.AfterReturning;import ng.annotation.AfterThrowing;import ng.annotation.Aspect;import ng.annotation.Before;import ng.annotation.Pointcut;/*** @author wyl* @Description TODO* @date 2016-10-18**/@Aspect //定义切⾯类public class LogAnnotationAspect {@SuppressWarnings("unused")//定义切⼊点,提供⼀个⽅法,这个⽅法的名字就是改切⼊点的id@Pointcut("execution(* com.demo..*(..))")private void allMethod(){}//针对指定的切⼊点表达式选择的切⼊点应⽤前置通知@Before("allMethod()")public void before(JoinPoint call) {String className = call.getTarget().getClass().getName();String methodName = call.getSignature().getName();System.out.println("开始执⾏:"+className+"."+methodName+"()⽅法...");}//访问命名切⼊点来应⽤后置通知@AfterReturning("allMethod()")public void afterReturn(JoinPoint call) {String className = call.getTarget().getClass().getName();String methodName = call.getSignature().getName();System.out.println(className+"."+methodName+"()⽅法正常执⾏结束...");}//应⽤最终通知@After("allMethod()")public void after(JoinPoint call) {String className = call.getTarget().getClass().getName();String methodName = call.getSignature().getName();System.out.println(className+"."+methodName+"()最终执⾏步骤(finally)...");}//应⽤异常抛出后通知@AfterThrowing("allMethod()")public void afterThrowing(JoinPoint call) {String className = call.getTarget().getClass().getName();String methodName = call.getSignature().getName();System.out.println(className+"."+methodName+"()⽅法抛出了异常...");}//应⽤周围通知//@Around("allMethod()")public Object doAround(ProceedingJoinPoint call) throws Throwable{Object result = null;this.before(call);//相当于前置通知try {result = call.proceed();this.afterReturn(call); //相当于后置通知} catch (Throwable e) {this.afterThrowing(call); //相当于异常抛出后通知throw e;}finally{this.after(call); //相当于最终通知}return result;}}。
Spring技术内幕——深入解析Spring架构与设计原理(二)AOP
Spring技术内幕——深入解析Spring架构与设计原理(二)AOPAOP联盟定义的AOP体系结构把与AOP相关的概念大致分为了由高到低、从用法到实现的三个层次。
关于这个体系结构,个人的理解是这样的,从上往下,最高层是语言和开发环境,在这个环境中可以看到几个重要的概念:base可以视为待增加对象,或者说目标对象;aspect指切面,通常包含对于base的增加应用;configuration可以看成是一种编织或者说配置,通过在AOP体系中提供这个configuration配置环境,可以把base和aspect结合起来,从而完成切面向目标对象的编织实现。
对Spring平台或者说生态系统来说,AOP是Spring框架的核心功能模块之一。
AOP与IOC容器的结合用法, 为应用开发或者Spring自身功能的扩展都提供了许多方便。
Spring AOP的实现和其他特性的实现一样,十分丰盛,除了可以用法Spring本身提供的AOP实现之外,还封装了业界优秀的AOP解决计划AspectJ来让应用用法。
在这里,主要对Spring自身的AOP实现原理做一些解析;在这个AOP实现中,Spring 充分利用了IOC容器Proxy代理对象以及AOP拦截器的功能特性,通过这些对AOP基本功能的封装机制,为用户提供了AOP的实现框架。
所以,要了解这些AOP的基本实现,需要我们对Java 的Proxy机制有一些基本了解。
AOP实现的基本线索 AOP实现中,可以看到三个主要的步骤,一个是代理对象的生成,然后是拦截器的作用,然后是Aspect编织的实现。
AOP框架的丰盛,很大程度体现在这三个详细实现中,所具有的丰盛的技术挑选,以及如何实现与IOC容器的无缝结合。
究竟这也是一个十分核心的模块,需要满足不同的应用需求带来的解决计划需求。
在Spring AOP的实现原理中,我们主要举ProxyFactoryBean的实现作为例子和实现的基本线索举行分析;很大一个缘由,是由于ProxyFactoryBean是在Spring IoC环境中,创建AOP应用的最底层办法,从中,可以看到一条实现AOP的基本线索。
aop的实现方法
AOP(面向切面编程)的实现方法有以下几种:
1.静态AOP:在编译期,切面直接以字节码的形式编译到目标字节码文件中。
实现原理
是为被代理的业务接口生成代理类,将AOP逻辑写入到代理类中,在运行时动态织入AOP,使用反射执行织入的逻辑。
主要实现方式依赖ng.reflect包下的InvocationHandler和Proxy类。
2.动态代码字节生成:在运行期,目标类加载后,动态构建字节码文件生成目标类的子类,
将切面逻辑加入到子类中。
CGLib是动态代码字节生成的实现,它封装字节码生成工具Asm,原理是在运行期间目标字节码加载后,生成目标类的子类,将切面逻辑加入到子类中,所以使用Cglib实现AOP不需要基于接口。
3.自定义类加载器:在运行前,目标加载前,将切面逻辑加到目标字节码中。
可以考虑
javassist来实现。
代码编写过程中如何设计和实现日志记录
代码编写过程中如何设计和实现日志记录?在软件开发过程中,日志记录是一种重要的技术手段,能够帮助开发者快速定位和解决问题。
日志记录可以记录系统的运行状态、异常信息、用户操作等,对于软件的稳定性、可维护性和灵活性都有很大的帮助。
以下是设计和实现日志记录的一些建议和步骤:1.确定日志记录的目的和内容:首先要明确日志记录的目的,例如调试和排查问题、性能分析、用户行为分析等。
然后确定需要记录哪些信息,例如时间戳、线程号、类名、方法名、异常信息等。
2.选择适当的日志记录框架:市场上有许多优秀的日志记录框架,例如log4j、logback、slf4j等,可以根据自身的需求和技术栈选择合适的框架。
这些框架通常提供了强大的日志记录功能,并且有助于提高日志的性能和可读性。
3.确定日志级别:日志级别可以分为调试(debug)、信息(info)、警告(warn)、错误(error)和致命(fatal)等级别,根据实际需求确定需要记录的日志级别。
通常在开发环境中可以设置为调试级别,而在生产环境中可以设置为信息级别或以上,避免记录过多的调试信息。
4.打印日志:在代码中通过日志记录框架提供的接口打印日志。
一般来说,可以在代码的关键节点、异常处理代码块和用户操作等地方进行日志记录。
同时,可以通过在日志记录中添加上下文信息,例如当前请求的URL、用户ID等,方便追踪和分析问题。
5.日志格式化:为了提高日志的可读性,可以对日志的格式进行适当的调整。
例如可以将日志信息按照一定的格式输出,包括时间戳、日志级别、线程号、类名、方法名等。
同时,可以使用占位符等技术,将动态的信息以参数形式传入,方便灵活记录不同的日志信息。
6.异常处理:在捕获异常时,可以将异常的相关信息记录到日志中,方便后续分析和定位问题。
可以记录异常的堆栈信息、异常类型、异常的原因等。
7.设置日志的配置文件:日志记录框架通常提供了配置文件,可以通过配置文件来控制日志的输出位置、输出格式、日志级别等。
springAOP实现操作日志记录,并记录请求参数与编辑前后字段的具体改变
springAOP实现操作⽇志记录,并记录请求参数与编辑前后字段的具体改变本⽂为博主原创,未经允许不得转载: 在项⽬开发已经完成多半的情况下,需要开发进⾏操作⽇志功能的开发,由于操作的重要性,需要记录下操作前的参数和请求时的参数,在⽹上找了很多,没找到可⾏的⽅法.由于操作⽇志⽤注解⽅式的AOP记录操作⽇志⽐较便捷,所以想到了在注解中定义操作前查询数据详情的bean,查询⽅法及参数,参数类型,在aop进⾏⽅法执⾏前,对指定的bean,⽅法,参数进⾏调⽤,获得修改前的参数,并进⾏保存.此处需要注意:1.在前⾯中调⽤指定bean的⽅法时,不可⽤反射进⾏调⽤,反射不能加载spring容器,⽆法获取指定的spring bean,下⾯⽅法中封装的获取spring bean的 ⼯具类也需要配置为bean,⽽且被spring加载,才可以;2.@Aspect注解的类⼀定要配置成bean,⽽且被spring加载,才可以,即同时配置@Component和@Aspect,或在spring的配置⽂件进⾏bean的配置3.如果配置了bean,要检索component-scan扫描范围是否包括Aspect类;⼀.定义切⾯执⾏的注解(该注解可根据⾃⼰实现的内容进⾏⾃定义)1 import ng.annotation.Documented;2 import ng.annotation.Retention;3 import ng.annotation.Target;45 import ng.annotation.ElementType;6 import ng.annotation.RetentionPolicy;78 @Target({ElementType.PARAMETER, ElementType.METHOD})9 @Retention(RetentionPolicy.RUNTIME)10 @Documented11 public @interface SystemControllerLog {1213 /**查询模块*/14 String module() default "";1516 /**查询模块名称*/17 String methods() default "";1819 /**查询的bean名称*/20 String serviceClass() default "";2122 /**查询单个详情的bean的⽅法*/23 String queryMethod() default "";2425 /**查询详情的参数类型*/26 String parameterType() default "";2728 /**从页⾯参数中解析出要查询的id,29 * 如域名修改中要从参数中获取customerDomainId的值进⾏查询30 */31 String parameterKey() default "";3233 /**是否为批量类型操作*/34 boolean paramIsArray() default false;3536 }⼆.切⾯执⾏的⽅法12import ng.reflect.Method;3import java.text.SimpleDateFormat;4import java.util.Date;56import javax.servlet.http.HttpServletRequest;7import javax.servlet.http.HttpSession;89import ng3.StringUtils;10import ng.ProceedingJoinPoint;11import ng.Signature;12import ng.annotation.Around;13import ng.annotation.Aspect;14import ng.annotation.Pointcut;15import ng.reflect.MethodSignature;16import org.slf4j.Logger;17import org.slf4j.LoggerFactory;18import org.springframework.beans.factory.annotation.Autowired;19import ponent;20import org.springframework.util.ReflectionUtils;21import org.springframework.web.context.request.RequestContextHolder;22import org.springframework.web.context.request.ServletRequestAttributes;2324import com.alibaba.fastjson.JSON;25import com.alibaba.fastjson.JSONArray;26import com.alibaba.fastjson.JSONObject;27import mon.RequestResult;28import mon.enums.FucdnStrConstant;29import com.suning.fucdn.entity.log.SystemControllerLogInfo;30import com.suning.fucdn.impl.service.log.LogServiceImpl;31import com.suning.fucdn.vo.AdminUserVO;3233/**34 *35 * 〈⼀句话功能简述:操作⽇志切⾯记录操作〉<br>36 * 〈功能详细描述〉37 *38 * @author xiang39 * @see [相关类/⽅法](可选)40 * @since [产品/模块版本] (可选)41*/42 @Component43 @Aspect44public class ControllerLogAopAspect {4546private static final Logger LOGGER = LoggerFactory.getLogger(ControllerLogAopAspect.class);4748//注⼊service,⽤来将⽇志信息保存在数据库49 @Autowired50private LogServiceImpl logservice;5152//配置接⼊点,如果不知道怎么配置,可以百度⼀下规则 //指定controller的类进⾏切⾯ @Pointcut("execution(* com.controller..CustomerController.*(..))||execution(* com.controller.ManageController.*(..))")53 @Pointcut("execution(* com.controller..*.*(..))")54private void controllerAspect(){55 System.out.println("point cut start");56 }//定义⼀个切⼊点5758 @SuppressWarnings({ "rawtypes", "unused" })59 @Around("controllerAspect()")60public Object around(ProceedingJoinPoint pjp) throws Throwable {61//常见⽇志实体对象62 SystemControllerLogInfo log = new SystemControllerLogInfo();63//获取登录⽤户账户64 HttpServletRequest httpRequest = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();6566//⽅法通知前获取时间,为什么要记录这个时间呢?当然是⽤来计算模块执⾏时间的67//获取系统时间68 String time = new SimpleDateFormat(FucdnStrConstant.YEAR_MONTH_DAY_HOUR_MINUTE_SECOND.getConstant()).format(new Date());69 log.setStartTime(time);7071//获取系统ip,这⾥⽤的是我⾃⼰的⼯具类,可⾃⾏⽹上查询获取ip⽅法72//String ip = GetLocalIp.localIp();73//log.setIP(ip);7475// 拦截的实体类,就是当前正在执⾏的controller76 Object target = pjp.getTarget();77// 拦截的⽅法名称。
Java Spring框架的详细使用教程
Java Spring框架的详细使用教程Java Spring框架是一个轻量级的开源框架,用于简化Java应用程序的开发。
它提供了许多功能和组件,能够帮助开发人员快速构建可扩展、可维护的企业级应用程序。
本文将详细介绍Java Spring框架的使用,包括框架的特点、核心概念和常用模块的介绍。
Java Spring框架的特点1. 轻量级:Java Spring框架采用了基于POJO(普通Java对象)的开发模式,不依赖于任何特定的容器或服务器,因此非常轻量级。
2. 面向切面编程(AOP):Java Spring框架支持面向切面编程,可以通过AOP来实现一些横切关注点,如事务管理、日志记录等。
3. 控制反转(IoC):Java Spring框架采用了控制反转的设计模式,将对象的创建、管理和依赖关系的维护交给框架来处理,使得开发人员能够更专注于业务逻辑的实现。
4. 声明式事务管理:Java Spring框架提供了事务管理的功能,可以通过简单的配置来实现声明式的事务管理,而无需编写复杂的事务控制代码。
Java Spring框架的核心概念1. IoC容器:IoC容器是Java Spring框架的核心部分,它负责对象的创建和管理。
开发人员将对象的实例化和依赖关系的维护交给IoC容器来处理,从而实现了对象的解耦和配置的灵活性。
2. Bean:在Java Spring框架中,被IoC容器所管理的对象被称为Bean。
Bean可以通过注解或XML配置的方式进行定义和配置。
3. AOP:面向切面编程是Java Spring框架的一个重要特性,开发人员可以通过AOP将一些横切关注点(如日志、安全、事务等)从业务逻辑中剥离出来,并在需要的时候进行统一的管理。
4. MVC框架:Java Spring框架提供了一个基于MVC(Model-View-Controller)模式的Web框架,通过将请求、处理和响应分离,使得Web应用程序的开发更加模块化和灵活。
Spring系列之AOP实现的两种方式
Spring系列之AOP实现的两种⽅式Spring只⽀持XML⽅式⽽没有实现注解的⽅式(也叫AspectJ⽅式)的AOP,所以要使⽤@Aspect注解,只能引⼊AspectJ相关的 jar 包:aopalliance-1.0.jar 和 aspectjweaver.jarSpring的配置⽂件 applicationContext.xml 中引⼊context、aop对应的命名空间;配置⾃动扫描的包,同时使切⾯类中相关⽅法中的注解⽣效,需⾃动地为匹配到的⽅法所在的类⽣成代理对象。
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:aop="/schema/aop"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans.xsd/schema/aop /schema/aop/spring-aop-4.0.xsd/schema/context /schema/context/spring-context-4.0.xsd"><!-- 配置⾃动扫描的包 --><context:component-scan base-package="com.qcc.beans.aop"></context:component-scan><!-- ⾃动为切⾯⽅法中匹配的⽅法所在的类⽣成代理对象。
--><aop:aspectj-autoproxy></aop:aspectj-autoproxy></beans>AOP常⽤的实现⽅式有两种,1、采⽤声明的⽅式来实现(基于XML),2、是采⽤注解的⽅式来实现(基于AspectJ)。
Spring面试,IoC和AOP的理解,@Transactional原理及使用
Spring⾯试,IoC和AOP的理解,@Transactional原理及使⽤spring 的优点?1.降低了组件之间的耦合性,实现了软件各层之间的解耦2.可以使⽤容易提供的众多服务,如事务管理,消息服务等3.容器提供单例模式⽀持4.容器提供了AOP技术,利⽤它很容易实现如权限拦截,运⾏期监控等功能5.容器提供了众多的辅助类,能加快应⽤的开发6.spring对于主流的应⽤框架提供了集成⽀持,如hibernate,JPA,Struts等7.spring属于低侵⼊式设计,代码的污染极低8.独⽴于各种应⽤服务器9.spring的DI机制降低了业务对象替换的复杂性10.Spring的⾼度开放性,并不强制应⽤完全依赖于Spring,开发者可以⾃由选择spring的部分或全部什么是DI机制?依赖注⼊(Dependecy Injection)和控制反转(Inversion of Control)是同⼀个概念,具体的讲:当某个⾓⾊需要另外⼀个⾓⾊协助的时候,在传统的程序设计过程中,通常由调⽤者来创建被调⽤者的实例。
但在spring中创建被调⽤者的⼯作不再由调⽤者来完成,因此称为控制反转。
创建被调⽤者的⼯作由spring来完成,然后注⼊调⽤者因此也称为依赖注⼊。
spring以动态灵活的⽅式来管理对象,注⼊的两种⽅式,设置注⼊和构造注⼊。
设置注⼊的优点:直观,⾃然构造注⼊的优点:可以在构造器中决定依赖关系的顺序。
什么是AOP?⾯向切⾯编程(AOP)完善spring的依赖注⼊(DI),⾯向切⾯编程在spring中主要表现为两个⽅⾯1.⾯向切⾯编程提供声明式事务管理2.spring⽀持⽤户⾃定义的切⾯⾯向切⾯编程(aop)是对⾯向对象编程(oop)的补充,⾯向对象编程将程序分解成各个层次的对象,⾯向切⾯编程将程序运⾏过程分解成各个切⾯。
AOP从程序运⾏⾓度考虑程序的结构,提取业务处理过程的切⾯,oop是静态的抽象,aop是动态的抽象,是对应⽤执⾏过程中的步骤进⾏抽象,,从⽽获得步骤之间的逻辑划分。
软件架构专业毕业设计基于SpringBoot的微服务架构设计与实现
软件架构专业毕业设计基于SpringBoot的微服务架构设计与实现一、引言随着互联网的快速发展,软件系统的规模和复杂度不断增加,传统的单体应用已经无法满足需求。
微服务架构作为一种新型的架构风格,逐渐成为了当前软件开发的主流趋势。
本文将围绕基于SpringBoot的微服务架构设计与实现展开讨论,探讨如何利用SpringBoot框架构建高效、可扩展、易维护的微服务系统。
二、微服务架构概述微服务架构是一种将单一应用程序划分为一组小型服务的架构风格。
每个服务都运行在自己的进程中,并通过轻量级通信机制(通常是HTTP API)相互通信。
相比传统的单体应用,微服务架构具有更好的灵活性、可伸缩性和可维护性。
三、SpringBoot简介SpringBoot是由Pivotal团队提供的开源框架,它基于Spring 框架,可以简化Spring应用程序的开发过程。
SpringBoot通过约定大于配置的方式,让开发者能够更快速地搭建基于Spring的应用程序。
同时,SpringBoot内置了Tomcat等容器,使得应用程序可以直接以jar包形式运行。
四、微服务架构设计在设计微服务架构时,需要考虑以下几个方面: 1. 服务拆分:将单体应用拆分为多个小型服务,每个服务关注一个特定的业务功能。
2. 服务通信:采用轻量级通信机制进行服务之间的通信,常见的方式包括RESTful API和消息队列。
3. 服务注册与发现:使用服务注册中心来管理各个微服务实例,并实现动态发现。
4. 负载均衡:通过负载均衡策略来分发请求到不同的微服务实例上,提高系统整体性能。
5. 容错处理:在微服务架构中,需要考虑各种故障情况下的容错处理机制,保证系统的稳定性。
五、基于SpringBoot的微服务实现1. 项目初始化首先,我们需要创建一个SpringBoot项目作为微服务系统的基础。
可以使用Spring Initializr来快速初始化一个空白项目,并添加所需的依赖。
《2024年基于SpringBoot的学生信息管理系统的设计与实现》范文
《基于SpringBoot的学生信息管理系统的设计与实现》篇一一、引言随着信息化时代的快速发展,学生信息管理已经成为教育机构不可或缺的重要环节。
基于SpringBoot的学生信息管理系统,旨在通过高效、稳定的技术架构,实现学生信息的集中化、规范化管理。
本文将详细介绍该系统的设计思路与实现过程。
二、系统需求分析1. 业务需求:系统需满足学校对学生信息的管理需求,包括学生基本信息录入、查询、修改、删除等操作。
2. 用户需求:系统应支持管理员、教师、学生等不同角色的用户进行操作,并保证数据的安全性和隐私性。
3. 技术需求:采用SpringBoot框架,实现系统的快速开发、部署及维护。
三、系统设计1. 系统架构设计:采用前后端分离的设计思想,后端使用SpringBoot框架,前端采用流行的Vue.js等框架。
系统架构分为表示层、业务逻辑层、数据访问层,各层之间通过接口进行通信。
2. 数据库设计:选用关系型数据库MySQL,设计学生信息表、课程信息表、成绩信息表等,以支持系统的业务需求。
3. 用户权限设计:系统支持多种角色用户,包括管理员、教师、学生等,不同角色拥有不同的权限,以保证数据的安全性。
四、系统功能实现1. 登录功能:系统支持多种登录方式,包括账号密码登录、微信、QQ等第三方登录。
登录后,系统根据用户角色赋予相应的权限。
2. 学生信息管理:包括学生基本信息录入、查询、修改、删除等功能。
通过数据访问层与数据库进行交互,实现学生信息的增删改查。
3. 课程与成绩管理:系统支持课程信息的录入、查询及成绩的录入、查询、统计等功能。
教师可以在系统中发布课程信息,学生可以查看并选择课程,同时教师还可以录入学生的成绩并进行统计。
4. 系统管理:包括用户管理、权限管理、日志管理等功能。
管理员可以在系统中添加、删除、修改用户信息,设置用户权限,查看系统日志等。
五、技术实现细节1. SpringBoot框架:采用SpringBoot框架,实现系统的快速开发、部署及维护。
数据库课程设计工作日志系统
数据库课程设计工作日志系统工作日志系统是一种方便记录工作内容、计划和进度的工具,本文将介绍一个基于数据库设计的工作日志系统。
1. 系统需求该系统需要满足以下需求:- 可以记录个人或团队的工作日志;- 可以记录任务的名称、描述、创建时间、截止时间等信息;- 可以记录工作进度、完成情况等信息;- 可以对任务进行分类、筛选和排序;- 可以支持多种用户角色和权限;- 可以提供基础数据分析功能。
2. 数据库设计为满足上述需求,我们设计了以下数据库模型:- 用户(user):记录用户的基本信息,包括ID、账户名、密码、邮箱、角色等字段;- 任务(task):记录任务的基本信息,包括ID、名称、描述、创建时间、截止时间等字段;- 工作日志(log):记录任务的工作日志,包括ID、任务ID、工作内容、工作时间、工作进度等字段;- 分类(category):记录任务的分类信息,包括ID、名称等字段;- 系统配置(config):记录系统配置信息,包括ID、名称、值等字段。
3. 系统实现基于上述数据库模型,我们实现了一个简单的工作日志系统。
该系统使用了Spring Boot框架、Thymeleaf模板引擎和MySQL数据库。
具体功能包括:- 用户管理:支持管理员添加、删除用户,普通用户修改自己的信息;- 任务管理:支持管理员添加、删除、修改任务,普通用户查看、修改自己负责的任务;- 工作日志:支持管理员查看所有工作日志,普通用户查看自己的工作日志,可以按照任务、时间等条件筛选和排序;- 分类管理:支持管理员添加、删除、修改分类信息,可以对任务进行分类;- 系统配置:支持管理员修改系统配置,包括任务默认截止时间、每页显示数量等。
4. 总结该工作日志系统基于数据库设计,并实现了基本的用户管理、任务管理、工作日志、分类管理和系统配置等功能。
通过该系统,用户可以方便地记录工作内容和任务进度,并进行数据分析,提高工作效率和管理质量。
java aop切面日志写法
java aop切面日志写法
在Java中,AOP(面向切面编程)可以用来实现日志记录。
通常情况下,你可以使用AOP来在方法执行前后记录日志,以下是一种常见的切面日志写法:
首先,你需要创建一个切面类,用来定义日志记录的行为。
这个切面类需要使用注解或者XML配置来指定在哪些方法执行前后应该记录日志。
在这个切面类中,你需要编写方法,在方法执行前后分别记录日志。
接下来,你需要配置AOP,告诉程序在哪些地方应该使用这个切面。
你可以使用注解或者XML配置来指定切面的作用范围,比如哪些包下的哪些类的哪些方法需要使用这个切面。
在切面类中,你可以使用Java的日志框架(比如log4j、logback等)来记录日志。
在方法执行前后,你可以分别记录方法的输入参数、方法的返回值,以及方法的执行时间等信息。
总的来说,实现AOP切面日志的写法可以分为以下几个步骤:
1. 创建切面类,定义日志记录的行为。
2. 配置AOP,指定切面的作用范围。
3. 在切面类中使用日志框架记录日志。
这种方式能够帮助你在不修改原有业务逻辑的情况下,实现统一的日志记录,提高代码的可维护性和可扩展性。
当然,具体的实现方式会根据你的项目框架和需求有所不同,但是以上提到的步骤是一个通用的实现思路。
springboot—springaop实现系统操作日志记录存储到数据库
springboot—springaop实现系统操作⽇志记录存储到数据库原⽂:https:///p/d0bbdf1974bd采⽤⽅案:使⽤spring 的 aop 技术切到⾃定义注解上,针对不同注解标志进⾏参数解析,记录⽇志缺点是要针对每个不同的注解标志进⾏分别取注解标志,获取参数进⾏⽇志记录输出1. 需要引⽤的依赖<!--spring切⾯aop依赖--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId></dependency>在application.properties⽂件⾥加这样⼀条配置spring.aop.auto=true //这个配置我的例⼦中没有加也正常运⾏2. 创建实体类public class SysLog implements Serializable {private Long id;private String username; //⽤户名private String operation; //操作private String method; //⽅法名private String params; //参数private String ip; //ip地址private Date createDate; //操作时间//创建getter和setter⽅法}3. 使⽤spring 的 aop 技术切到⾃定义注解上,所以先创建⼀个⾃定义注解类import ng.annotation.*;/*** ⾃定义注解类*/@Target(ElementType.METHOD) //注解放置的⽬标位置,METHOD是可注解在⽅法级别上@Retention(RetentionPolicy.RUNTIME) //注解在哪个阶段执⾏@Documented //⽣成⽂档public @interface MyLog {String value() default "";}4. 创建aop切⾯实现类import com.alibaba.fastjson.JSON;import com.qfedu.rongzaiboot.annotation.MyLog;import com.qfedu.rongzaiboot.entity.SysLog;import com.qfedu.rongzaiboot.service.SysLogService;import com.qfedu.rongzaiboot.utils.HttpContextUtils;import com.qfedu.rongzaiboot.utils.IPUtils;import com.qfedu.rongzaiboot.utils.ShiroUtils;import ng.JoinPoint;import ng.annotation.AfterReturning;import ng.annotation.Aspect;import ng.annotation.Pointcut;import ng.reflect.MethodSignature;import org.springframework.beans.factory.annotation.Autowired;import ponent;import javax.servlet.http.HttpServletRequest;import ng.reflect.Method;import java.util.Date;/*** 系统⽇志:切⾯处理类*/@Aspect@Componentpublic class SysLogAspect {@Autowiredprivate SysLogService sysLogService;//定义切点 @Pointcut//在注解的位置切⼊代码@Pointcut("@annotation( com.qfedu.rongzaiboot.annotation.MyLog)")public void logPoinCut() {}//切⾯配置通知@AfterReturning("logPoinCut()")public void saveSysLog(JoinPoint joinPoint) {System.out.println("切⾯。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
基于Spring和AOP的数据库认证日志的设计与实现
作者:陈焕英,马静婕
来源:《电脑知识与技术》2011年第09期
摘要:项目开发中,类似于数据库验证、参数合法性验证、异常处理、事务控制等的业务处理方法有很多,而他们的健壮性直接影响着整个项目的健壮性。
在以前的开发中,就要反反复复地写每个业务的代码,为解决这些繁琐的方方面面的代码编写,Spring中的AOP应运而生,将程序中涉及的公共业务问题分离成一个个方面,很好地利用方面编程解决了这些问题。
关键词:Spring;AOP;数据库认证;日志管理
中图分类号:TP311文献标识码:A文章编号:1009-3044(2011)09-1982-02
Design and Implementation of Log about Database User Authentication Base on Spring and AOP CHEN Huan-ying, MA Jing-jie
(Henan Quantity Engineering Occupation College, Pingdingshan 467001, China)
Abstract: There is a lot of businesses like database authentication, parameter's validation and abnormal process in the project development. The robustness of project is affected by their robustness. Using the old development, we describe repeatedservice code. The Spring and AOP can resolve these problems. The aspect is separated from topical business in progrom, using the aspect can efficiently solve the repetitive work.
Key words: Spring;AOP;database authentication;log administration
1 概述
1.1 什么是Spring
Spring是一个开源框架,它由Rod Johnson创建。
它是为了解决企业应用开发的复杂性而创建的。
Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。
然而,Spring的用途不仅限于服务器端的开发。
从简单性、可测试性和松耦合的角度而言,任何Java应用都可以从Spring中受益。
Spring框架是一个分层架构,由 7 个定义良好的模块组成[1]。
Spring 模块构建在核心容器之上,核心容器定义了创建、配置和管理 bean 的方式,如图1所示。
组成 Spring 框架的每个模块(或组件)都可以单独存在,或者与其他一个或多个模块联合实现。
每个模块的功能如下:
1) 核心容器:核心容器提供 Spring 框架的基本功能。
2) Spring 上下文:Spring 上下文是一个配置文件,向 Spring 框架提供上下文信息。
3) Spring AOP:Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。
4) Spring DAO:JDBC DAO 抽象层提供了有意义的异常层次结构,可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。
5) Spring ORM:Spring 框架插入了若干个 ORM 框架,从而提供了 ORM 的对象关系工具。
6) Spring Web 模块:Web上下文模块建立在应用程序上下文模块之上,为基于 Web 的应用程序提供了上下文。
7) Spring MVC 框架:MVC框架是一个全功能的构建 Web 应用程序的 MVC 实现。
1.2什么是AOP[2]
AOP——Aspect Oriented Programming, 简称AOP,面向方面/切面的编程。
AOP是一种编程模式,提供从另一个角度来考虑程序结构以完善面向对象编程(OOP)。
AOP为开发者提供了一种描述横切关注点的机制,并能够自动将横切关注点织入到面向对象的软件系统中,从而实现了横切关注点的模块化。
日志、事务、安全验证等这些通用的、散步在系统各处的需要在实现业务时关注的事情就称为“方面”,也称为“关注点”。
2 AOP的实现原理
项目开发中一般的业务处理有记录日志,合法性检验等。
1) 将业务系统中这些日志、事务、安全验证等操作分离为单个的方面,集中处理,如图2所示。
实现特定功能的方面代码在AOP概念中又称为“通知(Adivice)”,通知分为前置通知、后置通知、环绕通知和异常通知。
前置通知是在业务执行前自动执行的通知;后置通知是在业务执行后自动执行的通知;环绕通知能力最强,它可以在业务调用前执行通知代码,可以决定是否还调用目标方法;异常通知是业务方法抛出异常时自动执行的方面代码。
2) 讲方面分离出后,就专一的开发业务功能代码。
3) 通过Spring的代理方式将方面(即通知)织入到业务对象中。
AOP实现原理如图3所示。
3 以项目开发中的数据库登录验证日志管理为例讲解Spring与AOP的实现及运用
1) 数据库登录用户业务关键代码如示例1所示:
示例1:
public class UserBiz {
public User login(User user){
UserDao userDao=new UserDao();
User userg=userDao.login(user);
return userg;
}}
2) 使用前置通知实现方面代码如示例2所示:
示例2:
public class LogAdvice implements MethodBeforeAdvice {
private static DateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 hh时mm分ss 秒");
public void before(Method m, Object[] args, Object target)
throws Throwable {
//Method m:被通知目标方法对象
//Object[] args:传入被调方法的参数
//Object target:被调方法所属的对象实例
System.out.println("\n[系统日志][" + sdf.format(new Date()) + "]"
+ m.getName()
+ "("+ Arrays.toString(args) + ")"
+" the method belong to "+target.getClass().getName());
}}
3) 使用Spring代理将方面代码织入业务对象中,关键代码如示例3所示:
示例3:
class="org.Springframework.aop.framework.ProxyFactoryBean">
aop.BookBiz
logAdvice
afterAdvice
aroundAdvice
ExcepAdvice
4 总结
无论是业务方法中,还是调用业务方法的代码中,都看不到日志代码的蛛丝马迹,可运行的时候,确实输出了日志代码(用户登录过)的信息。
通过使用Spring AOP,我们将日志代码分离出去,基本上不需要改动原来的代码,通过简单的配置,业务系统就具备了日志的能力。
这样很好的提高了代码的重用性,这也就是Spring AOP备受大家欢迎的原因所在。
参考文献:
[1] 陈天河.struts、hibernate、Spring集成开发宝典[M].北京:电子工业出版社,2007:488.
[2] 徐袛祥.开发基于Struts+Spring+Hibernate的网上交易系统[M].北京:科学技术文献技术出版社,2008,182.。