Spring注释笔记

已于 2022-10-12 16:42:19 修改
阅读量374 收藏
点赞数
分类专栏： 笔记 文章标签： java spring servlet
于 2022-09-23 16:57:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GLENN_GR/article/details/127013867
版权

目录

创建 bean 实例

Spring 针对 Bean 管理中创建对象提供注解

属性注入

AOP 操作

配置

@Aspect 标定增强类

@Before 前置通知

 @Pointcut 相同的切入点抽取

@AfterReturning 后置通知（返回通知）

@After 最终通知

@AfterThrowing 异常通知

@Around 环绕通知

@Order 设置增强类优先级

AOP测试实现实例

JdbcTemplate

@Transactional 开启事务的注解

所需依赖:

在 spring 配置文件开启事务注解

声明式事务管理参数配置

事务的传播行为:

创建 bean 实例

Spring 针对 Bean 管理中创建对象提供注解

1）@Component ：将类标识为普通组件

2）@Service ：将类标识为业务层组件

3）@Controller r：将类标识为控制层组件

4）@Repository ：将类标识为持久层组件

开启组件扫描

 <context:component-scan base-package="com.gr.spring">
        <!--
            context:exclude-filter:排除扫描
                type:设置排除扫描的方式 annotation:根据注解排除扫描
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
        -->
 </context:component-scan>

 创建类，在类上面添加创建对象注解

@Service(value = "userService")
public class UserService { 
    public void add() {
        System.out.println("service add.......");
    }
}

属性注入

@Autowired：根据属性类型进行自动装配

@Qualifier：根据名称进行注入,必须与@Autowired同时使用

@Resource：可以根据类型注入，可以根据名称注入

@Value：注入普通类型属性

AOP 操作

配置

在 spring 配置文件中，开启注解扫描,开启生成代理对象

<!-- 开启注解扫描 -->
<context:component-scan base-package="com.atguigu.spring5.aopanno"></context:component-scan>
<!-- 开启 Aspect 生成代理对象-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

创建类，在类里面定义方法 (被代理类)

public class User {
     public void add() {
         System.out.println("add.......");
     }
}

@Aspect 标定增强类

注释在创建的增强类上，创建方法，让不同方法代表不同通知类型 (代理类)

增强的类 

@Component
@Aspect //生成代理对象
public class UserProxy {
    public void before() {//前置通知
        System.out.println("before......");
    }
}

@Before 前置通知

//@Before 注解表示作为前置通知
@Before(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void before() {
    System.out.println("before.........");
}

 @Pointcut 相同的切入点抽取

/*
相同切入点抽取
第一个*号代替“权限修饰符”和“返回值”部分表示“权限修饰符”和“返回值”不限
第二个*号,类名部分整体用*号代替，表示类名任意
第三个*号,在方法名部分，可以使用*号表示方法名任意
在方法参数列表部分，使用(..)表示参数列表任意
*/
@Pointcut("execution(* com.atguigu.spring5.aopanno.*.*(..))")
public void pointcut(){}

//JoinPoint参数 获取被增强类属性
@Before("pointCut()")
public void before(JoinPoint joinPoint){
      //获取链接点所对应方法的签名信息
      Signature signature = joinPoint.getSignature();
      //获取链接点所对应方法的参数
      Object[] args = joinPoint.getArgs();
      System.out.println("LoggerAspect,方法:"+signature.getName()+",参数"+ Arrays.toString(args));
    }

@AfterReturning 后置通知（返回通知）

/**
* 在返回通知中若要获取目标对象方法的返回值
* 只需要通过@AfterReturning注解的returning属性
* 就可以将通知方法的某个参数指定为接收目标对象方法的返回值的参数
*/
@AfterReturning(value = "pointCut()", returning = "result")
public void afterReturningAdviceMethod(JoinPoint joinPoint, Object result){
    //获取连接点所对应方法的签名信息
    Signature signature = joinPoint.getSignature();
    System.out.println("LoggerAspect，方法："+signature.getName()+"，结果："+result);
}

@After 最终通知

@After("pointCut()")
public void after() {
    System.out.println("after.........");
}

@AfterThrowing 异常通知

/**
* 在异常通知中若要获取目标对象方法的异常
* 只需要通过AfterThrowing注解的throwing属性
* 就可以将通知方法的某个参数指定为接收目标对象方法出现的异常的参数
*/
@AfterThrowing(value = "pointCut()", throwing = "ex")
public void afterThrowingAdviceMethod(JoinPoint joinPoint, Throwable ex){
    //获取连接点所对应方法的签名信息
    Signature signature = joinPoint.getSignature();
    System.out.println("LoggerAspect，方法："+signature.getName()+"，异常："+ex);
}

@Around 环绕通知

@Around("pointCut()")
//环绕通知的方法的返回值一定要和目标对象方法的返回值一致
public Object aroundAdviceMethod(ProceedingJoinPoint joinPoint){
    Object result = null;
    try {
        System.out.println("环绕通知-->前置通知");
        result = joinPoint.proceed();
        System.out.println("环绕通知-->返回通知");
    } 
    catch (Throwable throwable) {
        throwable.printStackTrace();
        System.out.println("环绕通知-->异常通知");
    } finally {
        System.out.println("环绕通知-->后置通知");
    }
    return result;
}

@Order 设置增强类优先级

在增强类上面添加注解 @Order(数字类型值)，数字类型值越小优先级越高

@Component
@Aspect
@Order(1)
public class PersonProxy{}

AOP测试实现实例

@Test
public void test(){
      //获取IOC容器
      ApplicationContext ioc = new ClassPathXmlApplicationContext("aop-annotation.xml");
      //创建AOP实现类.类型选择接口的类型(如Calculator)而非Object
      Calculator calculator = ioc.getBean(Calculator.class);
      calculator.div(1,1);
}

JdbcTemplate

什么是 JdbcTemplate

Spring 框架对 JDBC 进行封装，使用 JdbcTemplate 方便实现对数据库操作

加入依赖:

    <packaging>jar</packaging>
    <dependencies>
        <!-- 基于Maven依赖传递性，导入spring-context依赖即可导入当前所需所有jar包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.1</version>
        </dependency>
        <!-- Spring 持久化层支持jar包 -->
        <!-- Spring 在执行持久化层操作、与持久化层技术进行整合过程中，需要使用orm、jdbc、tx三个
        jar包 -->
        <!-- 导入 orm 包就可以通过 Maven 的依赖传递性把其他两个也导入 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>5.3.1</version>
        </dependency>
        <!-- Spring 测试相关 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.3.1</version>
        </dependency>
        <!-- junit测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- MySQL驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.16</version>
        </dependency>
        <!-- 数据源 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.31</version>
        </dependency>
    </dependencies>

在 spring 配置文件配置数据库连接池:

<!--引入jdbc.properties-->
<context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="${jdbc.driver}"></property>
    <property name="url" value="${jdbc.url}"></property>
    <property name="username" value="${jdbc.user}"></property>
    <property name="password" value="${jdbc.password}"></property>
</bean>
<!--注入 dataSource-->
<bean class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"></property>
</bean>

测试类写法:

//指定当前测试类在spring的测试环境中执行,此时就可以通过注入的方式直接获取IOC容器中的bean
@RunWith(SpringJUnit4ClassRunner.class)
//设置spring测试环境的配置文件
@ContextConfiguration("classpath:spring-jdbc.xml")
public class JdbcTest {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    //增删改方式:
    @Test
    public void test(){
        String sql = "insert into t_user values(0,?,?,?,?,?)";
        jdbcTemplate.update(sql,"admin","123",22,"女","123@126.com");
    }
    //条件查询:
    @Test
    public void testUserById(){
        String sql = "select * from t_user where id = ?";
        User user = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(User.class), 3);
        System.out.println(user);
    }
    //查询所有:
    @Test
    public void testAllUser(){
        String sql = "select * from t_user";
        List<User> query = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(User.class));
        query.forEach(System.out::println);
    }
    //查询单行单列数据
    @Test
    public void testCount(){
        String sql = "select count(*) from t_user";
        Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
        System.out.println(count);
    }
}

@Transactional 开启事务的注解

所需依赖:

    <packaging>jar</packaging>
    <dependencies>
        <!-- 基于Maven依赖传递性，导入spring-context依赖即可导入当前所需所有jar包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.1</version>
        </dependency>
        <!-- Spring 持久化层支持jar包 -->
        <!-- Spring 在执行持久化层操作、与持久化层技术进行整合过程中，需要使用orm、jdbc、tx三个
        jar包 -->
        <!-- 导入 orm 包就可以通过 Maven 的依赖传递性把其他两个也导入 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>5.3.1</version>
        </dependency>
        <!-- Spring 测试相关 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.3.1</version>
        </dependency>
        <!-- junit测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- MySQL驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.16</version>
        </dependency>
        <!-- 数据源 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.31</version>
        </dependency>
    </dependencies>

在 spring 配置文件开启事务注解

    <!--扫描组件-->
    <context:component-scan base-package="com.gr.spring"></context:component-scan>
    <!--引入jdbc.properties-->
    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.user}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    <!--配置JdbcTemplate-->
    <bean class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--开启事务的注解驱动-->
    <tx:annotation-driven transaction-manager="transactionManager"/>

事务测试类:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:tx_annotation.xml")
public class TxByAnnotation {
    @Autowired
    private BookController bookController;
    @Test
    public void testByBook(){
        bookController.buyBook(1,2);
    }
}

在 service 类上面（或者 service 类里面方法上面）添加事务注解

（1）@Transactional，这个注解添加到类上面，也可以添加方法上面

（2）如果把这个注解添加类上面，这个类里面所有的方法都添加事务

（3）如果把这个注解添加方法上面，为这个方法添加事务

声明式事务管理参数配置

propagation：事务传播行为

       REQUIRED:如果事务在运行,当前的方法就在这个事务内运行.否则就启动一个新的事务,并在                              内运行

       REQUIRED-NEW:当前的方法必须启动新事务,并在内运行.如果有事务正在运行,应该将它挂起

ioslation：事务隔离级别

timeout：超时时间

readOnly：是否只读(true ; false)

rollbackFor：回滚

noRollbackFor：不回滚

事务的传播行为:

标记在开启事务的方法上,事务回滚的默认属性,出现异常时由开启事务的方法进行回滚

@Transactional(propagation = Propagation.REQUIRED)

标记在被调用的事务方法上,出现异常时由被调用的事务方法进行回滚

@Transactional(propagation = Propagation.REQUIRES_NEW)

GLENN_GR
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring学习笔记
03-24
Spring学习笔记Spring spring的配置 IOC 依赖注入 基于Xml的注入 基于注释的注入 Spring的自动注入和属性自动注入 AOP 静态代理 动态代理 使用spring实现AOP 基于Annotation实现AOP 基于XML实现AOP ...
spring+springMVC+WebSocket 的学习笔记
10-15
spring+springMVC+WebSocket 的学习笔记 ,超详细，源代码注释清晰，适合新手，赶紧下载吧，提高技术，面试升职加薪需要不断学习
【代码优化与重构技巧】切面获取返回值并发送mq
weixin_42246822的博客
08-19 1089
使用切面时获取返回值，并发送mq
spring @AfterReturning 返回值
weixin_38312502的博客
03-04 7810
@AfterReturning是用于做aop的，其中返回值的问题，坑了我比较久，特地写出来。 1. 正确的使用 @AfterReturning(value = "pointCut()", returning = "obj") public Object doAfterReturning(JoinPoint joinPoint, Object obj) { // 正常情况下，我们想要修改obj，只需要强转为对应的对象，再重新设置值即可，如下 User user = (User)obj;
Spring 14 AOP 配置管理 14.4 AOP 通知获取数据 14.4.3 获取返回值 & 14.4.4 获取异常
谢谢你们的关注
10-13 924
Spring 14 AOP 配置管理 14.4 AOP 通知获取数据 14.4.3 获取返回值 & 14.4.4 获取异常
springAop @AfterReturning注解 获取返回值
weixin_34413103的博客
02-28 8106
@AfterReturning(returning="rvt", pointcut="@annotation(com.sinosoft.redis.cache.PutCache)") public Object AfterExec(JoinPoint joinPoint,Object rvt){ 　　rvt 这个就是方法返回值 } 转载于:https://www.cnblogs...
Spring AOP通知获取数据（参数，返回值，异常）
阿博的博客
10-19 2452
Spring AOP通知获取数据（参数，返回值，异常）
Spring AOP切面通过@AfterReturning获取返回参数时返回null
lzhfdxhxm的博客
01-02 9215
@AfterReturning如果和@Around一起使用，那么就需要给@Around的方法设置返回参数，因为@AfterReturning接收到的值其实是@Around返回的。 如果@Around的方法没设置返回参数，有2种可能： 1.@AfterReturning接收到的返回值为null 2.如果目标方法的返回值类型不是封装类型如Integer，而是基本类型比如int，则执行会报错： ...
马士兵Spring课堂笔记(超级详细版).pdf
02-28
马士兵Spring课堂笔记（超级详细版） 本资源主要讲解了Spring框架的基础概念和应用，涵盖了面向接口编程、IOC/DI、AOP、Spring应用IOC/DI、Spring应用AOP、Struts2.1.6 + Spring2.5.6 + Hibernate3.3.2整合、Spring...
spring-learning:我的学习Spring和Spring Boot的笔记
04-16
此存储库包含有关对Spring Framework（v5.2.x）和Spring Boot（v2.4.x）的源代码进行分析的学习笔记。 我试图使这些注释尽可能地易于理解，因此，我主要将这些注释组织成图表，并结合一些微小的代码片段，以使说明...
java云笔记 项目+sql文件+超清晰注释+项目经验
07-11
Spring(MVC,IOC,AOP) MyBatis Ajax:异步请求响应处理;页面局部刷新 (所有请求一律采用Ajax方式交互) jQuery:简化js和Ajax编程,实现前端处理 SpringMVC:实现控制层,用于接收请求分发 给业务模型处理,并实现请求响应...
spring注解切面@AfterReturning取返回值
hacker_Lees的博客
12-13 1万+
/** * 案件状态更新的通知 * * @param joinPoint joinPoint */ @AfterReturning(value = "alertsCaseInfoPointcut()", returning = "result") public void doAfterUpdateCaseInfoStatus(JoinPoi...
AOP获取方法返回值
loet6010的博客
08-14 1万+
我们用Spring的AOP切面做日志收集或者记录的时候，在springboot中用@Aspect注解。比如： @Aspect public class AdviceTest { @Before("execution(* com.abc.service.*.many*(..))") public void permissionCheck(JoinPoint point) { System.out.println("@Before：模拟权限检查..."); Sy
Spring AOP 第一篇-初识Spring AOP
paralysed的博客
09-06 595
前言 前一篇文章讲了一些关于动态代理和拦截器链的内容，Spring AOP-动态代理和拦截器。本章的内容延续上一篇文章的样例，可以先看下上篇文章。其实动态代理就是 Spring AOP 的基础，我们通过动态代理可以实现增强被代理对象的功能，但是有一个问题，那就是太麻烦了，Spring AOP 就是解决这一问题的，使得被代理对象的增强变得简单，更有利于开发使用。 代码样例 引入需要的依赖 <dependency> <group...
Spring Aop AfterReturning接收返回值
aar49191的博客
12-27 2121
包结构: Spring.xml UserDao.java 测试类Main方法 LogAspect.java 测试结果: @AfterReturning标签属性分析: value值: 可以写Aop的表达式,如execution、args、within等,多个之间使用&& || ...
Spring注解大全（二）
daiyuenlong110的博客
01-30 430
@Pointcut 定义切点，切点表达式(execution(权限访问符 返回值类型 方法所属的类名包路径.方法名(形参类型) 异常类型)) @Aspect@Component public class AfterThrowingAspect { //全路径execution(public String com.cnblogs.hellxz.test.Test.access(String,String)) @Pointcut("execution(* com.cnblogs.hell
Spring中的AOP（五）——在Advice方法中获取目标方法的参数
weixin_33859504的博客
03-23 1295
为什么80%的码农都做不了架构师？>>> ...
AOP高级用法——获取方法的参数和返回值
热门推荐
qq_41899174的博客
06-01 3万+
我们平时在使用springAop的时候，经常是将某一个方法定义为一个切入点，用来做前置，后置或环绕增强，但如果想得到切入点方法的参数，以及它的返回值就需要做一些特定的配置。 普通的切面如下： @Configuration @Aspect public class UserInfoAspect { @Pointcut("execution(* com.*.test(*))") ...
Spring基础笔记
lalalalyx的博客
10-13 183
自己学习Spring基础时记录的笔记
spring 学习笔记
最新发布
04-10
Spring是一个开源的Java框架，用于构建企业级应用程序。它提供了一种轻量级的、非侵入式的开发方式，通过依赖注入和面向切面编程等特性，简化了Java应用程序的开发过程。 以下是关于Spring学习的一些笔记： 1. IoC（控制反转）：Spring通过IoC容器管理对象的创建和依赖关系的注入。通过配置文件或注解，将对象的创建和依赖关系的维护交给Spring容器来管理，降低了组件之间的耦合度。 2. DI（依赖注入）：Spring通过依赖注入将对象之间的依赖关系解耦。通过构造函数、Setter方法或注解，将依赖的对象注入到目标对象中，使得对象之间的关系更加灵活和可维护。 3. AOP（面向切面编程）：Spring提供了AOP的支持，可以将与业务逻辑无关的横切关注点（如日志、事务管理等）从业务逻辑中分离出来，提高了代码的可重用性和可维护性。 4. MVC（模型-视图-控制器）：Spring提供了一个MVC框架，用于构建Web应用程序。通过DispatcherServlet、Controller、ViewResolver等组件，实现了请求的分发和处理，将业务逻辑和视图展示进行了分离。 5. JDBC和ORM支持：Spring提供了对JDBC和ORM框架（如Hibernate、MyBatis）的集成支持，简化了数据库访问的操作，提高了开发效率。 6. 事务管理：Spring提供了对事务的支持，通过声明式事务管理和编程式事务管理，实现了对数据库事务的控制和管理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值