Spring5框架学习笔记(二)

最新推荐文章于 2024-09-06 11:04:13 发布
最新推荐文章于 2024-09-06 11:04:13 发布
阅读量112 收藏
点赞数
文章标签： spring aop java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pan_0312/article/details/115218324
版权

Spring5框架学习笔记(二)

AOP(概念)
  1. 什么是AOP?
    1. 面向切面编程，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑的各个部分之间的耦合度降低，提高程序的可重用性，同时提高了开发效率。
    2. 通俗描述：不通过修改源代码方式，在主干功能里面添加新功能。
AOP(底层原理)
  1. AOP底层使用动态代理
    有两种情况的动态代理:
    1. 第一种 有接口使用JDK动态代理，创建接口实现类代理对象，增强类的方法
    2. 第二种 无接口使用CGLIB动态代理，创建子类的代理对象，增强类的方法
  2. AOP(JDK动态代理)
    1. 使用JDK动态代理，使用Proxy类里面的方法创建代理对象,调用newProxyInstance方法
    public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
   //第一个参数：类加载器
   //第二个参数：增强方法所在的类，这个类实现的接口，支持多个接口
   //第三个参数：实现接口InvocationHandler，创建代理对象，写增强的方法
    1. JDK动态代理代码实现
    //1.创建接口，定义方法
public interface UserDao {
public int add(int a, int b);
public String update(String id);}

//2.创建接口实现类，实现方法
public class UserDaoImpl implements UserDao {
@Override
public int add(int a, int b) {
    return a+b;
}
@Override
public String update(String id) {
    return id;
}}

public class JDKProxy {

public static void main(String[] args) {
    //创建接口实现类代理对象
    Class[] interfaces = {UserDao.class};
    /*Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            return null;
        }
    });*/
    UserDao userDao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces , new UserDaoProxy(new UserDaoImpl()));
    int result = userDao.add(1,2);
    System.out.println("result:" + result);
}}

//创建代理对象代码
class UserDaoProxy implements InvocationHandler{

//传入被代理对象
private Object object;
public UserDaoProxy(Object o){
    this.object = o;
}

//增强逻辑
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    //方法之前执行
    System.out.println("方法之前执行。。。" + method.getName() + "参数"+ Arrays.toString(args));
    //被增强的方法执行
    Object res = method.invoke(object, args);
    //方法之后
    System.out.println("方法之后执行。。。"+ object);
    return res;
}}
AOP(术语)
  1. 连接点：类里面哪些方法可以被增强，这些方法被称为连接点
  2. 切入点：实际被真正增强的方法，被称为切入点
  3. 通知(增强)：实际增强的逻辑部分称为通知
    1. 前置通知
    2. 后置通知
    3. 环绕通知
    4. 异常通知
    5. 最终通知
  4. 切面：把通知应用到切入点的过程
AOP操作
  1. Spring框架一般都是基于AspectJ实现AOP操作，AspectJ不是Spring组成部分，独立AOP框架，一般把AspectJ和Spring框架一起使用，进行AOP操作
  2. 基于AspectJ实现AOP操作
    1. 基于xml配置文件实现
    2. 基于注解方式实现
  3. 切入点表达式
    1. 切入点表达式作用：知道对哪个类里面的哪个方法增强
    2. 语法结构：execution([权限修饰符][返回类型][类全路径][方法名称]（[参数列表]）)
AOP操作(AspectJ注解)
  1. 创建类，定义方法
public class User {
    public void add(){
        System.out.println("add...");
    }
}
  1. 创建增强类(编写增强逻辑)
    1. 在增强类里面，创建方法，让不同方法代表不同通知类型
public class UserProxy {
    public void before(){
        System.out.println("before...");
    }
}
  1. 进行注解的配置
    1. 在配置文件中开启注解的扫描
    2. 使用注解创建User和UserProxy对象
    3. 在增强类上加上@Asect
    4. 在Spring配置文件中开启生成代理对象
  2. 配置不同类型的通知
    1. 在作为通知方法上面添加通知类型注解，使用切入点表达式配置
<context:component-scan base-package="com.wp.spring5.aopanno"></context:component-scan>
    <!--开启AspectJ生成代理对象-->
    <aop:aspectj-autoproxy ></aop:aspectj-autoproxy>

@Component
@Aspect
public class UserProxy {

    //前置通知
    @Before(value = "execution(* com.wp.spring5.aopanno.User.add(..))")
    public void before(){
        System.out.println("before...");
    }
	//最终通知，方法后执行
    @After(value = "execution(* com.wp.spring5.aopanno.User.add(..))")
    public void after(){
        System.out.println("after...");
    }
	//后置通知(返回通知)，返回结果时执行
    @AfterReturning(value = "execution(* com.wp.spring5.aopanno.User.add(..))")
    public void afterReturning(){
        System.out.println("afterReturning...");
    }
	//异常通知
    @AfterThrowing(value = "execution(* com.wp.spring5.aopanno.User.add(..))")
    public void afterThrowing(){
        System.out.println("AfterThrowing...");
    }
    //环绕通知
    @Around(value = "execution(* com.wp.spring5.aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("Around...前置");
        proceedingJoinPoint.proceed();
        System.out.println("Around...后置");
    }
}

//运行结果
Around...前置
before...
add...
afterReturning...
after...
Around...后置

//出现异常运行结果
Around...前置
before...
AfterThrowing...
after...

java.lang.ArithmeticException: / by zero
  1. 相同的切入点抽取
//相同切入点抽取
    @Pointcut(value = "execution(* com.wp.spring5.aopanno.User.add(..))")
    public void pointdemo(){}

    //前置通知
    @Before(value = "pointdemo()")
    public void before(){
        System.out.println("before...");
    }
  1. 多个增强类对同一个方法增强，可设置优先级
    1. 在增强类上添加注解@Order(数字类型值)，数字类型值越小优先级越高
@Component
@Aspect
@Order(1)
public class PersonProxy
  1. 完全注解开发
@Configuration
@ComponentScan(basePackages = {"com.wp.spring5"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAop {
}
AOP操作(AspectJ配置文件)
<!--创建对象-->
<bean id="book" class="com.wp.spring5.aopxml.Book"></bean>
    <bean id="bookProxy" class="com.wp.spring5.aopxml.BookProxy"></bean>
    <!--配置aop增强-->
    <aop:config>
        <!--切入点-->
        <aop:pointcut id="p" expression="execution(* com.wp.spring5.aopxml.Book.buy(..))"/>
        <!--配置切面-->
        <aop:aspect ref="bookProxy">
            <!--增强作用在具体的方法上-->
            <aop:before method="before" pointcut-ref="p"></aop:before>
        </aop:aspect>
    </aop:config>
JdbcTemplate(概念和准备)
  1. 什么是JdbcTemplate？
    1. spring框架对jdbc进行封装，使用jdbcTemplate方便实现对数据库操作
    2. 准备工作
      在这里插入图片描述
<context:property-placeholder location="classpath:jdbc.properties"/>
    <!--配置连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${prop.driverClass}"></property>
        <property name="url" value="${prop.url}"></property>
        <property name="username" value="${prop.userName}"></property>
        <property name="password" value="${prop.password}"></property>
    </bean>
    <!--JdbcTemplate对象-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--注入DataSource-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
  1. JdbcTemplate数据库操作(添加)
String sql = "insert into t_book values(?, ?, ?)";
        Object[] args = {book.getUserId(), book.getUsername(), book.getUstatus()};
        int update = jdbcTemplate.update(sql, args);
  1. JdbcTemplate数据库操作(修改和删除)
@Override
    public void update(Book book) {
        String sql = "update t_book set username = ?, ustatus = ? where user_id = ?";
        Object[] args = {book.getUsername(), book.getUstatus(), book.getUserId()};
        int update = jdbcTemplate.update(sql, args);
        System.out.println(update);
    }

    @Override
    public void delete(String id) {
        String sql = "delete from t_book where user_id = ?";
        int update = jdbcTemplate.update(sql, id);
        System.out.println(update);
    }
  1. JdbcTemplate数据库操作(查询返回某个值)
@Override
    public int selectCount() {
        String sql = "select count(*) from t_book";
        return jdbcTemplate.queryForObject(sql, Integer.class);
    }
  1. JdbcTemplate数据库操作(查询返回对象)
//RowMapper:是接口，返回不同类型数据，使用这个接口里面实现类完成数据封装
<T> T queryForObject(String var1, RowMapper<T> var2, Object... var3) throws DataAccessException;

@Override
    public Book findBookInfo(String id) {
        String sql = "select * from t_book where user_id = ?";
        return jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class), id);
    }
  1. JdbcTemplate数据库操作(查询返回集合)
@Override
    public List<Book> findAllBook() {
        String sql = "select * from t_book";
        return jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
    }
  1. JdbcTemplate数据库操作(批量操作)
//批量新增
@Override
    public void batchAddBook(List<Object[]> batchArgs) {
        String sql = "insert into t_book values(?, ?, ?)";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }
//批量修改
@Override
    public void batchUpdateBook(List<Object[]> batchArgs) {
        String sql = "update t_book set username = ?, ustatus = ? where user_id = ?";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }
//批量删除
@Override
    public void batchDeleteBook(List<Object[]> batchArgs) {
        String sql = "delete from t_book where user_id = ?";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }
事务概念
  1. 什么是事务
    1. 事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有操作都失败
  2. 事务四个特性(ACID)
    1. 原子性
    2. 一致性
    3. 隔离性
    4. 持久性
  3. 在Spring进行事务管理操作
    1. 两种方式：编程式事务管理(代码中开启提交事务)和声明式事务管理
  4. 声明式事务管理
    1. 基于注解方式
    2. 基于xml配置文件方式
  5. 在Spring进行声明式事务管理，底层使用AOP
  6. Spring事务管理API
    1. 提供一个接口，代表事务管理器，这个接口针对不同框架提供不同的实现类
事务操作(注解声明式事务管理)
  1. 在spring配置文件配置事务管理器
<!--创建事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
  1. 在spring配置文件中，开启事务注解
<!--开启事务注解-->
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
  1. 在service类上(或者service类里面的方法上面)添加事务注解@Transactional
    1. 如果添加在类上面，这个类里面所有的方法都添加事务
    2. 如果添加在方法上面，为这个方法添加事务
事务操作(声明式事务管理参数配置@Transactional)

  1. propagation：事务传播行为

    1. 多事务方法直接进行调用，这个过程中事务是进行怎样管理的
      在这里插入图片描述

  2. isolation： 事务隔离级别

    1. 事务特性(隔离性)，多事务操作之间不会产生影响，不考虑隔离性会产生很多问题
    2. 三个读问题：脏读，不可重复读，幻读
    3. 脏读：一个未提交事务读取到另一个未提交事务的数据
    4. 不可重复读：一个未提交事务读取到另一个提交事务修改的数据
    5. 幻读：一个未提交事务读取到另一个提交事务添加的数据
    6. 解决：通过设置事务隔离级别，解决读 的问题
      在这里插入图片描述

  3. timeout：超时时间

    1. 事务需要在一定时间内进行提交，如果不提交进行回滚
    2. 默认值是-1，设置时间以秒单位进行计算

  4. readOnly：是否只读

    1. 读：查询操作，写：添加修改删除操作
    2. readOnly默认值false，表示可以查询，可以添加修改删除操作
    3. 设置readOnly值为true，只能查询

  5. rollbackFor：回滚

    1. 设置出现哪些异常进行事务回滚

  6. noRollbackFor：不回滚

    1. 设置出现哪些异常不进行事务回滚
@Service
@Transactional(rollbackFor = ClassNotFoundException.class,readOnly = false, timeout = -1, propagation = Propagation.REQUIRED, isolation = Isolation.REPEATABLE_READ)
public class UserService {}
事务操作(XML声明式事务管理)
<!--1.创建事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    
    <!--2.配置通知-->
    <tx:advice id="txadvice">
        <!--配置事务参数-->
        <tx:attributes>
            <!--指定那种规则的方法上面添加事务-->
            <tx:method name="accountMoney" propagation="REQUIRED"/>
            <!--<tx:method name="account*"/>-->
        </tx:attributes>
    </tx:advice>
    
    <!--3.配置切入点和切面-->
    <aop:config>
        <!--配置切入点-->
        <aop:pointcut id="pt" expression="execution(* com.wp.spring5.service.UserService.*(..))"/>
        <!--配置切面-->
        <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
    </aop:config>
事务操作(完全注解声明式事务管理)
  1. 创建配置类，使用配置类替代xml配置文件
@Configuration  //配置类
@ComponentScan(basePackages = "com.wp.spring5")  //组件扫描
@EnableTransactionManagement  //开启事务
public class TxConfig {

    //创建数据库连接池
    @Bean
    public DruidDataSource getDruidDataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/test");
        dataSource.setUsername("contact");
        dataSource.setPassword("contact");
        return dataSource;
    }

    //创建JdbcTemplate对象
    @Bean
    public JdbcTemplate getJdbcTemplate(DataSource dataSource){
        //到ioc容器汇中根据类型找到dataSource
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }

    //创建事务管理器
    @Bean
    public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource){
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }
}
pan_0312
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spring5框架学习笔记
11-29
Spring 5 框架学习笔记 本笔记主要介绍了 Spring 5 框架的相关知识点，包括 IoC 原理分析、基于 XML 的 IoC 实现、基于 XML 的 DI 使用、基于注解的 IoC 实现、Spring 纯注解实现方式、Spring 整合 Junit、Spring ...
Java Spring框架学习笔记（内附源码）.pdf
04-09
在本次的Java Spring框架学习笔记中，将对Spring框架的核心概念进行详细解析，包括Spring的 IOC（控制反转）、AOP（面向切面编程）、jdbcTemplate、事务管理、Spring5新特性以及与Mybatis的整合。本学习笔记提供了...
Spring5框架学习笔记
路遥
03-21 351
1.Spring5框架学习笔记 学习的时候看的是尚硅谷的Spring5课程，本来打算上传pdf，结果发现有人已经上传了，还设置为收费版，本人不能重复上传，所以打算自己写一下笔记，就当是复习和巩固了。但突然间浏览到一篇好兄弟的手敲笔记，基本上与视频中笔记一样，可放心食用。所以你懂的…，这里引用一下原文连接： Spring5框架学习笔记 感谢Jankiey的文章！ ...
Spring学习笔记（一）Spring框架入门
weixin_72154059的博客
02-06 1568
1、 我们经常挂在口中的Spring指的是（Spring 框架）它是一个开源框架，有着活跃而庞大的社区。这就是它之所以能长久不衰的原因，Spring支持广泛的应用场景，它可以让Java企业级开发应用程序开更简单。2、Spring是由Rod Johnson组织和开发的一个分层的Java SE/EE一站式（full-stack）轻量级开源框架。它最为核心的理念是IoC（控制反转）和AOP（面向切面编程），其中，IoC是Spring的基础，它支撑着Spring对JavaBean的管理功能；
Spring5学习笔记—整合MyBatis
分享思想，留下痕迹。
10-19 2万+
在我们之前的系列文章中，我们已经深入探讨了Spring5IOC和AOP，它们是Spring框架的基石。下面我们接着讨论开始讨论Spring5对于持久层框架MyBatis的整合，让我们一起开启新的的篇章吧。以上便是本文的全部内容，本人才疏学浅，文章有什么错误的地方，欢迎大佬们批评指正！我是Leo，一个在互联网行业的小白，立志成为更好的自己。如果你想了解更多关于Leo，可以关注公众号-程序员Leo，后面文章会首先同步至公众号。
Spring Cloud 学习笔记（1 / 3）
热门推荐
KISS
03-03 21万+
Spring Cloud 学习笔记（2 / 3） Spring Cloud 学习笔记（3 / 3） - - - 01_前言闲聊和课程说明 02_零基础微服务架构理论入门 03_第二季Boot和Cloud版本选型 04_Cloud组件停更说明 05_父工程Project空间新建 06_父工程pom文件 07_复习DependencyManagement和Dependencies 08_支付模块构建(上) 09_支付模块构建(中) 10_支付模块构建(下) 11_热部署Devtool
spring框架--全面详解（学习笔记）
swy2560666141的博客
02-26 1万+
由 Spring IoC 容器管理的对象称为 Bean，Bean 根据 Spring 配置文件中的信息创建。可以把 Spring IoC 容器看作是一个大工厂，Bean 相当于工厂的产品，如果希望这个大工厂生产和管理 Bean，则需要告诉容器需要哪些 Bean，以及需要哪种方式装配 Bean。Spring 配置文件支持两种格式，即 XML 文件格式和 Properties 文件格式。
Spring框架学习
qq_53957101的博客
09-30 2186
spring学习框架（简写）
Spring-尚硅谷-学习笔记
weixin_45581692的博客
10-10 6597
Spring框架是一个轻量级的开源的JavaEE框架。 Spring可以解决企业应用开发的复杂性。 Spring有两个核心部分：IOC和AOP IOC：控制反转，把创建对象的过程交给Spring AOP：面向切面，不修改源代码的情况下进行功能增强 Spring特点 方便解耦，简化开发 AOP编程支持 方便程序测试 方便和其他框架进行整合
SpringSecurity框架学习（尚硅谷的）
m0_59690068的博客
01-07 1911
*** * springboot项目启动类* * @SpringBootApplication 它的作用是将当前类标识为 Spring Boot 应用的入口点，并启用自动配置和组件扫描。* @Slf4j 在这里就是这个作用 log.info("项目启动成功。。。。。");* @Slf4j 用于自动为类生成一个名为 “log” 的日志对象。它是 Lombok 项目中提供的一个注解，通过在类上添加 @Slf4j 注解，* 可以方便地在代码中使用日志记录功能。**/
学习笔记：尚硅谷Spring6基础篇
D_boj的博客
08-14 3021
本章介绍，Spring6基础使用、Spring的IOC原理、Spring6整合日志框架、容器IOC、面向切面AOP以及依赖注入的方式、自动装配和依赖注入等
Spring 学习笔记(一)：Spring 框架简介及 IDEA 配置
qq_71946662的博客
04-24 2006
刚刚开始 Spring 框架，记录一下学到的东西和遇到的问题
马士兵老师spring框架学习笔记
02-28
马士兵老师是知名的Java教育专家，他的Spring框架学习笔记深入浅出，对于初学者和进阶者来说都是一份宝贵的资源。这份笔记涵盖了Spring的核心概念、配置、AOP（面向切面编程）、DI（依赖注入）等关键知识点。 1. **...
spring框架学习笔记.zip
08-28
Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java...
Spring5框架课堂笔记.7z
12-03
这份"Spring5框架课堂笔记.pdf"应该详细讲解了以上各知识点，并可能包含示例代码和实践指导，对于学习和进阶Spring框架是非常宝贵的资源。通过深入学习和实践，开发者可以有效地利用Spring5框架构建高效、可维护的...
SpringMVC启动与请求处理流程解析
最新发布
业精于勤荒于嬉，行成于思毁于随
09-06 889
实现了Controller接口的Bean对象实现了HttpRequestHandler接口的Bean对象添加了@RequestMapping注解的方法一个HandlerFunction对象@Override@Override@Component@Autowired@Bean.build();HandlerMapping负责去寻找Handler，并且保存路径和Handler之间的映射关系。
springboot服务器文件读取工具类
dashalen的博客
09-06 340
springboot服务器本地文件读取和网络文件读取
Spring理论知识（Ⅳ）——Spring Instrumentation模块
敢问路在何方，路在脚下
09-02 752
总的来说，Spring Instrumentation提供了类植入（Instrumentation）支持和类加载器的实现，可以在特定的应用服务器中使用。本质上是一种JVM级别（操作系统级别）的AOP，用到了代理java.lang.instrument（容器类）做动态Instrumentation是Java SE 5的新特性使用 Instrumentation，开发者可以构建一个独立于应用程序的代理程序（Agent），用来监测和协助运行在 JVM 上的程序，甚至能够替换和修改某些类的定义。
基于Spring和MybatisPlus下的Oracle转mysql语句语法适配修改
xingyuemengjin的博客
09-04 518
本文讲述了在Spring+MybatisPlus环境中，oracle数据库转为mysql后查询语法和代码的主要修改。
Spring框架学习笔记：IoC与AOP解析
"Spring_in_action_学习笔记" Spring框架是Java开发中的一个重要组成部分，以其轻量级、非侵入式的设计理念赢得了广泛的认可。本学习笔记主要涵盖了Spring的基础知识，包括核心特性和模块组成。 1. Spring核心特性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值