Web基础之Spring AOP与事务

最新推荐文章于 2024-11-02 08:17:07 发布
最新推荐文章于 2024-11-02 08:17:07 发布
阅读量132 收藏
点赞数
文章标签： web.xml java 数据库
原文链接：http://www.cnblogs.com/lixin-link/p/11470469.html
版权

Spring之AOP

AOP 全程Aspect Oriented Programming，直译就是面向切面编程。和POP、OOP相似，它也是一种编程思想。OOP强调的是封装、继承、多态，也就是功能的模块化。而AOP则是OOP的补充，它强调的是切面，在运行时动态地将代码切入到类的指定方法、指定位置上的编程思想，也就是将业务代码和业务前后的代码分离出来（解耦），将日志、权限验证等功能抽取出来然后重用。
在Spring中，采用动态代理的方式来表达AOP。（并非所有的AOP都是使用动态代理来，比如AspectJ采用编译时创建代理对象，比运行时创建效率更高）
动态代理一般有两种实现方式，一种是JDK原生动态代理，要求被代理对象必须实现接口，并且只能代理接口中的方法（本质是创建一个实现接口的代理对象）。另一种是CGlib，可以代理所有的方法（本质是创建一个代理对象，继承被代理对象）。Spring中使用的是CGlib的方式。

废话不多说，直接介绍Spring中的AOP。

Spring AOP相关术语

  • Joinpoint(连接点):任何可以被增强的方法，都称为连接点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点。
  • Pointcut(切入点):将要被增强的方法。即我们要对哪些Joinpoint进行拦截的定义。
  • Advice(通知/增强):所谓通知是指拦截到Joinpoint之后所要做的事情就是通知。通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。
  • Introduction(引介):Adivice是对方法进行增强的，而Introdution是针对类进行增强的
  • Target(目标对象):被代理的目标对象。
  • Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入。
  • Proxy(代理):一个对象被jdk代理或者cglib代理后的对象，称为代理
  • Aspect(切面):多个通知和切入点的配置关系。

基于xml的AOP配置

首先是依赖：

AOP依赖

<!--IOC相关依赖-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.0.6.RELEASE</version>
</dependency>
<!--junit-->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <scope>test</scope>
    <version>4.12</version>
</dependency>
<!-- AOP相关依赖 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.0.6.RELEASE</version>
</dependency>
<!-- spring集合junit的依赖 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.0.6.RELEASE</version>
</dependency>

然后配置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: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 -->
    <bean id="aspectService" class="com.bilibili.service.impl.AspectServiceImpl"></bean>
    <!-- 增强的功能bean -->
    <bean id="logger" class="com.bilibili.common.Logger"></bean>
    <!-- 配置AOP -->
    <aop:config>
        <!-- 配置切面
            id：唯一标识
            ref：引用的通知类(bean id)
        -->
        <aop:aspect id="logAdvice" ref="logger">
            <!-- 配置前置通知
                method：配置通知的方法（即增强的功能）
                pointcut：配置切面，也就是对哪个方法进行增强（使用AspectJ表达式）
                    execution：使用AspectJ切入点表达式
             -->
            <aop:before method="printLog" pointcut="execution(public void com.bilibili.service.impl.AspectServiceImpl.update())"></aop:before>
        </aop:aspect>
    </aop:config>
</beans>

execution表达式的匹配方式：

execution:匹配方法的执行(常用)
    execution(表达式)
表达式语法：execution([修饰符] 返回值类型 包名.类名.方法名(参数))
写法说明：
    全匹配方式：
        public void cn.bilibili.service.impl.AccountServiceImpl.saveAccount(cn.bilibili.domain.Account)
    访问修饰符可以省略   
        void cn.bilibili.service.impl.AccountServiceImpl.saveAccount(cn.bilibili.domain.Account)
    返回值可以使用*号，表示任意返回值
        * cn.bilibili.service.impl.AccountServiceImpl.saveAccount(cn.bilibili.domain.Account)
    包名可以使用*号，表示任意包，但是有几级包，需要写几个*
        * *.*.*.*.AccountServiceImpl.saveAccount(cn.bilibili.domain.Account)
    使用..来表示当前包，及其子包
        * cn..AccountServiceImpl.saveAccount(cn.bilibili.domain.Account)
    类名可以使用*号，表示任意类
        * cn..*.saveAccount(cn.bilibili.domain.Account)
    方法名可以使用*号，表示任意方法
        * cn..*.*( cn.bilibili.domain.Account)
    参数列表可以使用*，表示参数可以是任意数据类型，但是必须有参数
        * cn..*.*(*)
    参数列表可以使用..表示有无参数均可，有参数可以是任意类型
        * cn..*.*(..)
    全通配方式：
        * *..*.*(..)
注：
    通常情况下，我们都是对业务层的方法进行增强，所以切入点表达式都是切到业务层实现类。
    execution(* cn.bilibili.service.impl.*.*(..))

    注意：多个execution可以使用  ||  &&  连接

AOP 常用标签

  • <aop:config>：用于声明开始aop配置
  • <aop:aspect>：切面
    属性：
    • id：给切面提供一个唯一标识。
    • ref：引用配置好的通知类bean的id
  • <aop:point>：切点，方便一个切点多次使用
    属性：
    • id：切点的唯一标识
    • expression:定义切点的表达式
  • <aop:aspect>：前置通知
    属性：
    • method：通知的方法（即增强的功能）
    • pointcut：AspectJ表达式
    • pointcut-ref：引用切点（和pointcut不可同时使用）
  • <aop:after-returning>：后置通知
  • <aop:after-throwing>：异常通知
  • <aop:after>：最终通知（相当于finally）
  • <aop:around>：环绕通知，一般单独使用，该通知（增强的方法）接收一个类型为ProceedingJoinPoint的参数，该类型有一个proceed()方法，用来调用被代理方法。

基于注解的AOP配置

在主配置文件中开启包扫描和注解AOP：

<!-- 开启注解扫描的包 -->
<context:component-scan base-package="com.bilibili"></context:component-scan>

<!-- 开启注解AOP -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

把被代理对象注册到容器中：

AccountServiceImpl类

@Service("accountService")
public class AccountServiceImpl implements AccountService {
    public void update() {
        System.out.println("更新操作");
    }

    public void save() {
        System.out.println("保存操作");
    }

    public void delete() {
        System.out.println("删除操作");
    }
}

在通知类上添加@Component()进行注册，@Aspect表示切面类。方法上添加@Before()前置通知、@AfterReturning()后置通知、@AfterThrowing()异常通知、@After()最终通知。@Pointcut()注解空方法表示切面。

通知类

@Component("logger")
@Aspect//声明当前是一个切面类（通知类）
public class Logger {
    //注解前置通知，value属性就是切点的AspectJ表达式
    @Before("execution(* com.bilibili.service.impl.AccountServiceImpl.update())")
    public void beforePrintLog(){
        System.out.println("<aop:before>标签配置前置通知，即增强的功能在目标方法之前");
    }

    //切面
    @Pointcut("execution(* com.bilibili.service.impl.AspectServiceImpl.update())")
    public void pt1() {
    }

    //注解后置通知，引用切面
    @AfterReturning("pt1()")
    public void afterReturningPrintLog(){
        System.out.println("<aop:after-returning>标签配置后置通知,即增强的功能在目标方法之后");
    }
//下面就不一个一个标注了。
    public void afterThrowingPrintLog(){
        System.out.println("<aop:after-throwing>标签配置异常通知，即目标方法出现异常的时候执行");
    }

    public void afterPrintLog(){
        System.out.println("<aop:after>标签配置最终通知。即不管是否出现异常，都会执行，类似finally");
    }


    public Object aroundPrintLog(ProceedingJoinPoint pjp){
        Object obj = null;
        try {
            System.out.println("环绕通知，手动在代码中定义何时执行");
            obj = pjp.proceed();//目标方法执行
            System.out.println("环绕通知，手动在代码中定义何时执行");
        } catch (Throwable throwable) {
            System.out.println("环绕通知，手动在代码中定义何时执行");
            throwable.printStackTrace();
        }finally {
            System.out.println("环绕通知，手动在代码中定义何时执行");
        }
        return obj;
    }
}

纯注解配置

只需在IoC的纯注解配置类上添加@EnableAspectJAutoProxy()开启AOP即可。

注解AOP

//声明当前类是一个spring的配置类，用来替代xml配置文件
//获取容器时需要使用AnnotationApplicationContext(@Configuration标注的类.class)
@Configuration
//用于配置容器初始化时需要扫描的包
//和xml配置中<context:component-scan base-package="com.bilibili"/>作用一致
@ComponentScan("com.bilibili")
//导入其他配置类
@Import(JdbcConfig.class)
//开启AOP
@EnableAspectJAutoProxy
public class SpringConfig {

}

JdbcDaoSupport

继承该类后可以不用手动获取JdbcTemplate对象。

  1. dao层的实现类只需要继承JdbcDaoSupport,然后通过getJdbcTemplate()方法获取jdbcTemplate对象
  2. 在spring的applicationContext.xml中，只需要给dao的实现类注入dataSource数据源即可。因为JdbcDaoSupport中的setDataSource()方法自动创建jdbcTemplate对象。

使用这种方式无法用注解注入DataSource，只能通过xml注入（注入给子类也可以）

Spring 事务

事务处理位于业务层，Spring提供了一个spring-tx包来进行控制事务，事务是基于AOP，原理也比较好理解。

PlatformTransactionManager

PlatformTransactionManager：平台事务管理器,是Spring真正管理事务的对象，是一个接口，常用实现类有如下两个：

  • DataSourceTransactionManager：针对JDBC和mybatis事务管理
  • HibernateTransactionManager：针对Hibernate事务管理

Spring主要通过两个重要的接口来描述一个事务：

  • TransactionDefinition：事务定义的对象，用来定义事务的隔离级别、传播行为、是否只读、超时信息等等
  • TransactionStatus：事务状态信息的对象，用来获取事务是否保存、是否完成等。

Spring框架进行事务的管理，首先使用TransactionDefinition对事务进行定义。通过PlatformTransactionManager根据TransactionDefinition的定义信息进行事务的管理。在事务管理过程中产生一系列的状态：保存到TransactionStatus中。

TransactionDefinition接口具有以下常用方法：

  • String getName()：获取事务对象名称
  • int getIsolationLevel()：获取事务隔离级别
  • int getPropagationBehavior()：获取事务传播行为
  • int getTimeout()：获取事务超时时间
  • boolean isReadOnly()获取事务是否只读

事务隔离级别：

  • ISOLATION_DEFAULT：默认级别，会根据不同数据库自动变更（MySQL为可重复读，Oracle和Access为读已提交）
  • ISOLATION_READ_UNCOMMITTED：读未提交（会产生脏读）
  • ISOLATION_READ_COMMITTED:读已提交（解决脏读）
  • ISOLATION_REPEATABLE_READ：可重复读
  • ISOLATION_SERIALIZABLE：串行化

事务的传播行为

传播行为解决的问题： 一个业务层事务 调用 另一个业务层事务时，事务之间关系如何处理

事务传播行为PROPAGATION的取值：
    REQUIRED    支持当前事务，如果不存在，就新建一个（默认的传播行为）
        * 删除客户 删除订单， 处于同一个事务，如果 删除订单失败，删除客户也要回滚 
    SUPPORTS    支持当前事务，如果不存在，就不使用事务
    MANDATORY   支持当前事务，如果不存在，抛出异常


    REQUIRES_NEW    如果有事务存在，挂起当前事务，创建一个新的事务
        * 生成订单， 发送通知邮件， 通知邮件会创建一个新的事务，如果邮件失败， 不影响订单生成
    NOT_SUPPORTED   以非事务方式运行，如果有事务存在，挂起当前事务
    NEVER   以非事务方式运行，如果有事务存在，抛出异常
    

    NESTED  如果当前事务存在，则嵌套事务执行
        * 依赖于 JDBC3.0 提供 SavePoint 技术 
        * 删除客户 删除订单, 在删除客户后， 设置SavePoint, 执行删除订单，删除订单和删除客户在同一个事务 ，删除部分订单失败， 事务回滚 SavePoint , 由用户控制是事务提交 还是 回滚 

三个代表：
REQUIRED 一个事务， 要么都成功，要么都失败 
REQUIRES_NEW 两个不同事务，彼此之间没有关系  一个事务失败了 不影响另一个事务 
NESTED  一个事务， 在A事务 调用 B过程中， B失败了， 回滚事务到 之前SavePoint ， 用户可以选择提交事务或者回滚事务

超时时间：默认值是-1，没有超时限制。如果有，以秒为单位进行设置。

是否是只读事务：建议查询时设置为只读。

TransactionStatus：事务的运行状态，常用方法如下：

  • void flush()：刷新事务
  • boolean hasSavePoint()：是否存在存储点
  • boolean idComplated()：事务是否完成
  • boolean isNewTransaction()：是否为新事物
  • boolean isRollbackOnly()：事务是否回滚
  • void setRollbackOnly()设置事务回滚

xml方式配置事务

首先添加依赖：

一堆依赖

主要是spring-tx、spring-aspects这两个不要漏了。

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.0.6.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.0.6.RELEASE</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.38</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.0.9</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.0.6.RELEASE</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>5.0.6.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.0.6.RELEASE</version>
</dependency>

配置事务管理器的bean

<!-- 
    bean的名字叫做transactionManager,因为在配置事务策略的时候需要指定的事务管理器的默认名字就是transactionManager,如果是其他名字，在配置事务策略的时候，需要手动指定。 
-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"></property>
</bean>

配置事务策略：

<!-- 配置事务策略 -->
<tx:advice id="tx">
    <tx:attributes>
        <!--
            指定对那些方法使用事务
            name：需要进行事务管理的方法名 *代表所有方法，这里需要填方法的名字即可，不是aspectj那种包名加类名方法名。
            isolation:事务隔离级别
            propagation：事务传播行为
            timeout:超时时间
            ready-only:设置事务是否只读
            rollback-for:指定对哪种异常进行回滚
            no-rollback-for:指定对那种异常不进行回滚
         -->
        <tx:method name="*"  />
    </tx:attributes>
</tx:advice>

配置事务AOP：

<!-- 配置aop -->
<aop:config>
    <aop:pointcut id="pt1" expression="execution(* com.bilibili.service.impl.*.*(..))"></aop:pointcut>
    <!-- 配置事务策略运用到事务管理器 -->
    <aop:advisor advice-ref="tx" pointcut-ref="pt1"></aop:advisor>
</aop:config>

注解AOP

在spring主配置文件中：

<!-- 开启spring的注解扫描 -->
<context:component-scan base-package="com.bilibili"></context:component-scan>

<!-- 开启事务的注解扫描 -->
<tx:annotation-driven></tx:annotation-driven>

然后只在方法或者类或者接口上配置@Transactional即可开启事务

纯注解配置

在配置类上添加@EnableTransactionManagement开启注解事务管理：

纯注解配置类

@Configuration  //声明当前是一个配置类，用来代替applicationContext.xml文件
@ComponentScan("com.bilibili")  //开启注解包扫描
@PropertySource("classpath:jdbc.properties") // 加载外部配置文件
@EnableTransactionManagement // 开启注解事务管理
public class SpringConfig {
    
    @Value("${jdbc.url}")//引入外部配置文件中的资源
    private String url;
    @Value(("${jdbc.driverClass}"))
    private String driverClass;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    
    @Bean("dataSource")//将bean装配到spring容器中
    public DataSource getDataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(url);
        dataSource.setDriverClassName(driverClass);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return  dataSource;
    }

    @Bean("jdbcTemplate")
    public JdbcTemplate getJdbcTemplate(@Qualifier("dataSource") DataSource dataSource){
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        return  jdbcTemplate;
    }

    @Bean("transactionManager")
    public DataSourceTransactionManager getDataSourceTransactionManager(@Qualifier("dataSource") DataSource dataSource){
        DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager(dataSource);
        return dataSourceTransactionManager;
    }
}

Spring与Web之监听器

在Tomcat中，由于Servlet是Tomcat创建的，无法放入Spring中，当Servlet需要使用Service的时候是不太方便的，此时就可以使用监听器来自动创建ApplicationContext。

spring监听器原理：监听servletContext创建，创建ApplicationContext并将其放入上下文域。

自己实现：

创建一个servletContext监听器

@WebListener()
public class MyListener implements ServletContextListener {

    /**
     *  在ServletContext对象创建的时候，创建spring容器。
     *  1.创建spring容器，需要配置文件的名字，名字并不是固定的，所以可以配置在web.xml中
     *  2.spring容器创建之后，需要能够被所有的servlet来使用，那么需要将spring容器保存起来，保存到哪里？ServletContext域对象中
     *
     */
    @Override
    public void contextInitialized(ServletContextEvent servletContextEvent) {
        //获取servletContext域对象
        ServletContext servletContext = servletContextEvent.getServletContext();
        //读取web.xml中的配置参数 -- 即spring的核心配置文件的名字
        String contextConfig = servletContext.getInitParameter("contextConfig");
        //创建spring容器
        ApplicationContext ac = new ClassPathXmlApplicationContext(contextConfig);
        //将spring容器保存到servletContext对象中
        servletContext.setAttribute("ac",ac);
    }

    @Override
    public void contextDestroyed(ServletContextEvent servletContextEvent) {

    }
}

web.xml中配置spring配置文件位置：

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
    <!-- 配置spring核心配置文件的名字 -->
    <context-param>
        <param-name>contextConfig</param-name>
        <param-value>applicationContext.xml</param-value>
    </context-param>
</web-app>

然后在servlet中就可以获取servletContext中保存的ApplicationContext了。

使用Spring的监听器：

引入依赖：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>5.0.6.RELEASE</version>
</dependency>

web.xml中配置spring主文件位置和监听器：

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
    <!-- spring核心配置文件的位置
     key:是固定的
    value：格式固定，classpath:文件名
    -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>
    <!-- 告诉tomcat 用于创建spring容器的监听器的位置 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
</web-app>

然后就可以在servlet中使用下面的方式获取ApplicationContext：

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    ApplicationContext ac = WebApplicationContextUtils.getWebApplicationContext(this.getServletContext());
    userService = (UserService ) ac.getBean("userService");

    userService.register();
}

其实用了SpringMVC之后不会这么麻烦23333?

转载于:https://www.cnblogs.com/lixin-link/p/11470469.html

weixin_30572613
关注
#AOP的四种常用通知#前置通知、后置通知、异常通知、 最终通知#aop:before、aop:after-returning、aop:after-throwing、aop:after@FDDLC
LiuXingchang的博客
09-27 618
项目结构： pom.xml的内容： <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http:.
SpringAOP(图文详解)
lhj520cb的博客
07-16 4万+
Spring实现的AOP是代理模式，给调用者使用的实际是已经过加工的对象，你编程时方法体里只写了A，但调用者拿到的对象的方法体却是xAy。x和y总还是需要你来写的，这就是增强。x和y具体在什么时候被调用总还是需要你来规定的，虽然是基于约定的声明这种简单的规定，这就是切点。
Spring学习笔记（三）【AOP之切入点表达式及通知类型】
weixin_44270855的博客
08-15 432
在Spring基于XML的AOP配置中，我们需要在<aop:aspect>的内部使用对应标签来配置通知类型。假设配置前置通知： <aop:aspect id="xxx" ref="xxx"> <aop:before method="" pointcut=""></aop:before> </aop:aspect> 在<aop:before>标签中有两个属性： method属性：用于指定通知类中哪个方法是前置通知，即让哪个方法在切入
Spring中配置AOP的两种方式以及后置通知顺序的问题
zzq_jxw的博客
05-27 755
准备工作：目标类AdviceService, 注解方式的通知类MyAdvice, XML方式配置的通知类MyAdviceXML XML配置所用的通知类 MyAdviceXML： public class MyAdviceXML { public void before() { System.err.println("Before -- 前置通知 （XML配置）"); } public void afterReturning() { System.e
#AOP的四种常用通知#前置、后置、异常、 最终#aop:before、aop:after-returning、aop:after-throwing、aop:after#全注解无xml@FDDLC
LiuXingchang的博客
09-28 569
项目结构： pom.xml的内容： <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http:.
RabbitMQ使用指南
weixin_39341215的博客
12-15 371
rabbit mq windows 安装 注意事项 erlang 安装 下载地址 http://www.erlang.org/downloads 环境变量配置 ERLANG_HOME 安装路径 注意事项 安装erlang 时注意 一致 C:\Windows\System32\config\systemprofile\.erlang.cookie C:\Users\用户名\.erlang.cook...
Spring (三) 之Aop及事务控制
qq_45525848的博客
04-13 1105
Spring (三) 之Aop及事务控制
Spring之AOP的详细讲解
tq02的博客
04-09 5282
本文讲解的是SpringAOP，将切点、切面、通知点，逐步剖析，代码举例，配合理解！
springaop实现相关功能（事务、异常处理、记录日志）
唐昊
04-30 1448
当你的应用程序中的 com.example.myapp.service 包下的任意方法抛出异常时，ExceptionHandlingAspect 切面中的 handleException 方法将被自动调用，处理异常逻辑。事务管理器的类型取决于你使用的数据库和连接池。：虽然CGLIB代理在性能方面通常优于JDK动态代理，但由于它涉及到字节码操作，因此在创建代理类的过程中可能会存在一定的性能开销。：JDK动态代理要求目标对象必须实现至少一个接口，如果目标类没有实现任何接口，则无法使用JDK动态代理进行代理。
Spring AOP全面详解(超级详细)
热门推荐
Cr1556648487的博客
09-09 8万+
AOP （Aspect Orient Programming）,直译过来就是 面向切面编程,AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向切面编程，实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术，如下图所示：AOP可以拦截指定的方法并且对方法增强，而且无需侵入到业务代码中，使业务与非业务处理逻辑分离，比如Spring的事务，通过事务的注解配置，Spring会自动在业务方法中开启、提交业务，并且在业务处理失败时，执行相应的回滚策略。
spring aop实现用户权限管理的示例
08-28
在 Spring AOP 中，权限管理的代码实现与配置文件可以使用 execution 表达式来排除通用的 controller，选择合适的切点来实现权限管理。 知识点四：只读管理员权限的实现及切点选择 对于只读管理员权限的实现，可以...
Spring aop.docx
12-14
通过以上内容，你将能够了解Spring AOP的基础知识，如何在Spring Boot项目中使用AOP进行日志记录，并逐步掌握面向切面编程的精髓。继续深入学习，你将能够熟练运用Spring AOP解决实际问题，提升代码质量和可维护性。
spring-aop.rar_java aop_spring aop
09-23
【标题】"spring-aop.rar_java aop_spring aop" 涉及的主要知识点是Spring框架中的面向切面编程（AOP）以及Java基础知识。这个压缩包可能包含了一个简单的Spring AOP应用示例，同时也涵盖了Java的一些核心概念，如...
Spring-AOP.rar_spring aop 日志
09-14
Spring AOP，全称为Aspect-Oriented Programming，...同时，Spring AOP与Spring的其他功能（如DI、事务管理）结合使用，能够构建出强大的企业级应用。因此，深入理解和掌握Spring AOP对于Java Web开发者来说至关重要。
【JAVA高级编程-JavaWeb】作业4
天道的博客
11-01 601
14. (单选题, 1分)对于( )作用范围的Bean，当客户离开这个页面时JSP引擎取消为客户的该页面分配的Bean，释放他所占的内存空间。16. (填空题, 1分)__________是种运行在服务器端的Java应用程序，可以生成动态的Web页面，它属于客户和服务器响应的中间层。13. (单选题, 1分)( )作用范围将使Bean对象保存在服务器的内存空间中，在服务器关闭后被移除。15. (单选题, 1分)关于JavaBean，下列叙述中不正确的是( )。
手动编写一个Servlet
最新发布
qq_74947724的博客
11-02 280
servlet是基于java语言编写的服务端程序，主要功能是能够在服务器中执行并生成数据。特点：单进程，多线程。
Servlet 3.0 注解开发
长安初雪的博客
10-30 792
ervlet 3.0 注解开发
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 615
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
Spring AOP自主实现教程与java基础整合
Spring AOP（面向切面编程）是Spring框架的核心组件之一，它允许开发者将横切关注点（比如日志、事务管理等）与业务逻辑分离，以提高模块化。 标题“spring-aop.rar_java aop_spring aop”明确指出了资源内容的主题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值