Spring5框架 第二章

最新推荐文章于 2024-05-20 22:57:28 发布
最新推荐文章于 2024-05-20 22:57:28 发布
阅读量99 收藏
点赞数
分类专栏： Spring5 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52334927/article/details/116083896
版权

大家好，又来到了Spring框架学习的第二章节了。

这次我们要讲述的知识点如下。

1、Aop
2、JdbcTemplate

没错，就是两个内容，内容少方便学习。

言归正传，进入学习

Aop（概念）

1 、什么是 AOP
（1）面向切面编程（方面），利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得
业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
（2）通俗描述：不通过修改源代码方式，在主干功能里面添加新功能
（3）使用登录例子说明 AOP
如下图所示：

在这里插入图片描述

AOP （底层原理）

1 、AOP 底层使用动态代理
（1）有两种情况动态代理
在这里插入图片描述
在这里插入图片描述

AOP （JDK 动态代理）

1、使用 JDK 动态代理，使用 Proxy 类里面的方法创建代理对象
在这里插入图片描述
2 、编写 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;
    }
}

（3）使用 Proxy 类创建接口代理对象

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;
//            }
//        });
        UserDaoImpl userDao = new UserDaoImpl();
        UserDao dao =
                (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(),interfaces,
                        new UserDaoProxy(userDao));
        int result = dao.add(1,2);
        System.out.println("result:" + result);
    }
}

//创建代理对象代码
public class UserDaoProxy implements InvocationHandler {
    //1 把创建的是谁的代理对象,把谁传递过来
    //有参数构造传递
    private Object obj;
    public UserDaoProxy(Object obj){
        this.obj = obj;
    }
    //增强的逻辑
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //方法之前
        System.out.println("方法之前执行...."+method.getName()+" 传递的参数...:"+
                Arrays.toString(args));
        //被增强的方法执行
        Object res = method.invoke(obj,args);
        //方法之后
        System.out.println("方法之后执行...."+obj);
        return res;
    }
}

AOP（术语）

在这里插入图片描述
在这里插入图片描述

AOP 操作（准备 工作）

1 、Spring 框架一般都是基于 AspectJ 实现 AOP 操作
（1）AspectJ 不是 Spring 组成部分，独立 AOP 框架，一般把 AspectJ 和 Spirng 框架一起使用，进行 AOP 操作

2 、基于 AspectJ 实现 AOP 操作
（1）基于 xml 配置文件实现
（2）基于注解方式实现（使用）

3 、在项目工程里面引入 AOP 相关依赖
在这里插入图片描述
4 、切入点表达式
（1）切入点表达式作用：知道对哪个类里面的哪个方法进行增强
（2）语法结构： execution([权限修饰符] [返回类型] [类全路径] [方法名称][参数列表] )

举例 1：对 com.atguigu.dao.BookDao 类里面的 add 进行增强
execution(* com.atguigu.dao.BookDao.add(…))

举例 2：对 com.atguigu.dao.BookDao 类里面的所有的方法进行增强
execution(* com.atguigu.dao.BookDao.* (…))

举例 3：对 com.atguigu.dao 包里面所有类，类里面所有方法进行增强
execution(* com.atguigu.dao.. (…))

AOP 操作（AspectJ 注解）

1、创建类，在类里面定义方法

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

2 、创建增强类（编写增强逻辑）
（1）在增强类里面，创建方法，让不同方法代表不同通知类型

//增强的类
public class UserProxy {
    public void before() { //前置通知
        System. out .println( "before......");
    }
}

3 、进行通知的配置
（1）在 spring 配置文件中，开启注解扫描
在这里插入图片描述
（2）使用注解创建 User 和 UserProxy 对象
在这里插入图片描述
（3）在增强类上面添加注解 @Aspect

//增强的类
@Component
@Aspect //生成代理对象
public class UserProxy {

（4）在 spring 配置文件中开启生成代理对象

<!-- 开启 Aspect 生成代理对象-->
< aop:aspectj-autoproxy></aop :aspectj-autoproxy>

4 、配置不同类型的通知
（1）在增强类的里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置

//增强的类
@Component
@Aspect //生成代理对象
public class UserProxy {

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

    //后置通知(返回通知)
    @AfterReturning(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void afterReturning() {
        System.out.println("afterReturning......");
    }

    //最终通知
    @After(value = "execution(* com.atguigu.spring5.aopanno.User.add)")
    public void after(){
        System.out.println("after......");
    }

    //异常通知
    @AfterThrowing(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing......");
    }

    //环绕通知
    @Around(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("环绕之前......");
        //被增强的方法执行
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后......");
    }
}

5、相同的切入点抽取
//相同切入点抽取
    @Pointcut(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void pointdemo(){
    }

    //前置通知
    //@Before 注解表示作为前置通知
    @Before(value = "pointdemo()")
    public void before() {
        System.out.println("before......");
    }

6 、有多个增强类多同一个方法进行增强，设置增强类优先级
（1）在增强类上面添加注解 @Order(数字类型值)，数字类型值越小优先级越高
@Component
@Aspect
@Order(1)
public class PersonProxy

7 、完全使用注解开发
（1）创建配置类，不需要创建 xml 配置文件
@Configuration
@ComponentScan(basePackages = { "com.atguigu"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAop {
}

AOP 操作（AspectJ 配置文件）

1 、创建两个类，增强类和被增强类，创建方法
2 、在 spring 配置文件中创建两个类对象

<!--创建对象-->
    <bean id= "book" class= "com.atguigu.spring5.aopxml.Book"></bean>
    <bean id= "bookProxy" class= "com.atguigu.spring5.aopxml.BookProxy"></bean>

3 、在 spring 配置文件中配置切入点

<!--配置aop增强-->
    <aop:config>
        <!--切入点-->
        <aop:pointcut id="p" expression="execution(* com.atguigu.spring5.aopxml.Book.buy(..))"/>
        <!--配置切面-->
        <aop:aspect ref="bookProxy">
            <!--增强作用在具体的方法上-->
            <aop:before method="before" pointcut-ref="p"/>
        </aop:aspect>
    </aop:config>

JdbcTemplate( 概念和准备)

1 、什么是 JdbcTemplate
（1）Spring 框架对 JDBC 进行封装，使用 JdbcTemplate 方便实现对数据库操作

2 、准备工作
（1）引入相关 jar 包
在这里插入图片描述
（2）在 spring 配置文件配置数据库连接池

<!-- 数据库连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          destroy-method="close">
        <property name="url" value="jdbc:mysql:///user_db"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    </bean>

（3）配置 JdbcTemplate 对象，注入 DataSource

<!-- JdbcTemplate 对象 -->
    <bean id= "jdbcTemplate" class= "org.springframework.jdbc.core.JdbcTemplate">
        <!--注入 dataSource-->
        <property name= "dataSource" ref= "dataSource"></property>
    </bean>

（4）创建 service 类，创建 dao 类，在 dao 注入 jdbcTemplate 对象
配置文件

<!-- 组件扫描 -->
    <context:component-scan base-package="com.atguigu"></context:component-scan>

⚫ Service
    @Service
    public class BookService {
        //注入 dao
        @Autowired
        private BookDao bookDao;
    }
    
⚫ Dao
    @Repository
    public class BookDaoImpl implements BookDao {
        //注入 JdbcTemplate
        @Autowired
        private JdbcTemplate jdbcTemplate;
    }

JdbcTemplate 操作数据库（添加）

1、对应数据库创建实体类

public class User {
    private String userId;
    private String username;
    private String ustatus;

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getUstatus() {
        return ustatus;
    }

    public void setUstatus(String ustatus) {
        this.ustatus = ustatus;
    }
}

2 、编写 service 和 和 dao
（1）在 dao 进行数据库添加操作
（2）调用 JdbcTemplate 对象里面 update 方法实现添加操作
在这里插入图片描述
⚫ 有两个参数
⚫ 第一个参数：sql 语句
⚫ 第二个参数：可变参数，设置 sql 语句值

@Repository
public class BookDaoImpl implements BookDao {
    //注入 JdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;
    //添加的方法
    @Override
    public void add(Book book) {
        //1 创建 sql 语句
        String sql = "insert into t_book values(?,?,?)";
        //2 调用方法实现
        Object[] args = {book.getUserId(), book.getUsername(),
                book.getUstatus()};
        int update = jdbcTemplate.update(sql,args);
        System. out .println(update);
    }
}

3、测试类

@Test
    public void testJdbcTemplate() {
        ApplicationContext context =
                new ClassPathXmlApplicationContext( "bean1.xml");
        BookService bookService = context.getBean( "bookService",
                BookService. class);
        Book book = new Book();
        book.setUserId( "1");
        book.setUsername( "java");
        book.setUstatus( "a");
        bookService.addBook(book);
    }

在这里插入图片描述

JdbcTemplate 操作数据库（修改和删除）

1、修改
    @Override
    public void updateBook(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);
    }
    2、删除
    @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);
    }

JdbcTemplate 操作数据库（查询返回某个值）

1 、查询表里面有多少条记录，返回是某个值
2 、使用 JdbcTemplate 实现查询返回某个值代码
在这里插入图片描述
⚫ 有两个参数
⚫ 第一个参数：sql 语句
⚫ 第二个参数：返回类型 Class

//查询表记录数
    @Override
    public int selectCount() {
        String sql = "select count ( ( * ) from t_book";
        Integer count = jdbcTemplate.queryForObject(sql, Integer. class);
        return count;
    }

JdbcTemplate 操作数据库（查询返回对象）

1 、场景：查询图书详情
2 、JdbcTemplate 实现查询返回对象
在这里插入图片描述
⚫ 有三个参数
⚫ 第一个参数：sql 语句
⚫ 第二个参数：RowMapper 是接口，针对返回不同类型数据，使用这个接口里面 实现类完成数据封装
⚫ 第三个参数：sql 语句值

//查询返回对象
    @Override
    public Book findBookInfo(String id) {
        String sql = "select * from t_book where user_id=?";
        //调用方法
        Book book = jdbcTemplate.queryForObject(sql, new
                BeanPropertyRowMapper<Book>(Book.class), id);
        return book;
    }

JdbcTemplate 操作数据库（查询返回集合）

1 、场景：查询图书列表分页…
2 、调用 JdbcTemplate 方法实现查询返回集合
在这里插入图片描述
⚫ 有三个参数
⚫ 第一个参数：sql 语句
⚫ 第二个参数：RowMapper 是接口，针对返回不同类型数据，使用这个接口里面实现类完成数据封装
⚫ 第三个参数：sql 语句值

//查询返回集合
    @Override
    public List<Book> findAllBook() {
        String sql = "select * from t_book";
        //调用方法
        List<Book> bookList = jdbcTemplate.query(sql, new
                BeanPropertyRowMapper<Book>(Book.class));
        return bookList;
    }

JdbcTemplate 操作数据库（批量操作）

1 、批量操作：操作表里面多条记录
2 、JdbcTemplate 实现批量添加操作
在这里插入图片描述
⚫ 有两个参数
⚫ 第一个参数：sql 语句
⚫ 第二个参数：List 集合，添加多条记录数据

//批量添加
    @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));
    }

    // 批量添加测试
    List<Object[]> batchArgs = new ArrayList<>();
    Object[] o1 = {"3", "java", "a"};
    Object[] o2 = {"4", "c++", "b"};
    Object[] o3 = {"5", "MySQL", "c"};
    batchArgs.add(o1);
    batchArgs.add(o2);
    batchArgs.add(o3);
    //调用批量添加
    bookService.batchAdd(batchArgs);

3 、JdbcTemplate 实现批量 实现批量 修改操作

//批量修改
    @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));
    }

    // 批量修改
    List<Object[]> batchArgs = new ArrayList<>();
    Object[] o1 = {"java0909", "a3", "3"};
    Object[] o2 = {"c++1010", "b4", "4"};
    Object[] o3 = {"MySQL1111", "c5", "5"};
    batchArgs.add(o1);
    batchArgs.add(o2);
    batchArgs.add(o3);
    //调用方法实现批量修改
    bookService.batchUpdate(batchArgs);

4 、JdbcTemplate 实现批量 实现批量 删除操作

//批量删除
    @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));
    }

    // 批量删除
    List<Object[]> batchArgs = new ArrayList<>();
    Object[] o1 = {"3"};
    Object[] o2 = {"4"};
    batchArgs.add(o1);
    batchArgs.add(o2);
    //调用方法实现批量删除
    bookService.batchDelete(batchArgs);

本次讲解到此结束。

忘崽牛奶~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第二章 使用SpringCloud框架实现一个微服务.pdf
09-13
第二章 使用SpringCloud框架实现一个微服务.pdf
第十二章 ： Spring Boot 日志框架详解
RodJohnsonDoctor的专栏
11-22 1485
本章知识重点：介绍了日志诞生背景，4种日志框架：Logback、Log4j、Log4j2和Slf4j的优劣势分析，以及重点介绍了log4j2的应用示例以及配置，以及日志框架应用中遇到常见的问题以及如何处理。
Java EE：第6章初识Spring框架 课后习题
WHT869706733的博客
03-31 1387
《Java EE企业级应用开发教程 第2版（Spring+Spring MVC+MyBatis）》黑马程序员编著 中国工信出版集团 人民邮电出版社 目录 1、请简述MyBatis框架与Hibernate框架的区别。 2、请简述MyBatis的工作执行流程。 1、请简述MyBatis框架与Hibernate框架的区别。 Hibernate和MyBatis。这两个框架的主要区别如下： （1）Hibernate：是一个全表映射的框架。通常开发者只需定义好持久化对象到数据库表的映射关系，就可以通过H
JAVA学习笔记15——Spring框架第二章
我是紫色紫色的专栏
11-01 3216
今天内容介绍1. Spring框架的IOC基于注解的方式 2. Spring框架整合JUnit单元测试 3. AOP的概述 4. AOP的底层实现原理（了解） 5. AOP功能基于AspectJ的配置文件方式 技术分析之Spring框架的IOC功能之注解的方式Spring框架的IOC之注解方式的快速入门1. 步骤一：导入注解开发所有需要的jar包 * 引入IOC容器必须的6个jar包
第二章 Spring中的Bean
weixin_46066900的博客
05-20 7798
1、以下有关Bean的singleton作用域说法错误的是（）。 A、prototype是Spring容器默认的作用域 B、对需要保持会话状态的Bean（如Struts2的Action类）应该使用prototype作用域 C、在使用prototype作用域时，Spring容器会为每个对该Bean的请求都创建一个新的实例 D、要将Bean定义为prototype作用域，只需在配置文件中将元素的scope属性值设置为prototype即可 参考答案 :A 2、以下有关Bean的装配方式说法正确的是（）。 A、S
框架设计--第二章 Spring中的Bean--习题答案
热门推荐
三桥君
02-20 2万+
说明：框架设计（Spring）其他章节的习题答案也在此专栏 一、填空题 所谓自动装配，就是将一个Bean自动的注入到到其他Bean的【 Property 】中。 @Controller通常作用在控制层，如Spring MVC的【Controller】，用于将控制层的类标识为Spring中的Bean，其功能与@Component 相同。 【 @Repository 】注解用于将数据...
Spring攻略 英文第二版
08-01
随着Spring框架最新版本——3.0版的发布，Spring平台已经发展成熟，成为Java、Java虚拟机、Groovy、NET或者Action-Script开发人员最强大、最具革命性的解决方案之一。 《Spring攻略(第2版)》是Spring平台的深入指南...
spring入门经典源码第二章
08-30
Spring入门经典 一书全面透彻地介绍Spring Framework;Spring Framework是Java开发领域最流行的框架,是事实上的企业级应用开发标准
Spring攻略(第二版)高清版
07-08
随着Spring框架最新版本——3.0版的发布，Spring平台已经发展成熟，成为Java、Java虚拟机、Groovy、NET或者Action-Script开发人员最强大、最具革命性的解决方案之一。 《Spring攻略(第2版)》是Spring平台的深入指南...
Spring攻略PDF版
03-07
绝对是spring攻略中文版第二版 Spring专家力作 理论与实践完美结合 问题描述→解决方案→实现方法 第一部分　核心概念 　第1章　控制反转和容器　 　1.1　使用容器管理组件　 　1.1.1　问题描述　 　1.1.2　...
(三)Spring教程——依赖注入与控制反转
05-14 557
Spring有两个重要的接口：BeanFactory和ApplicationContext，所谓的容器就是实现了BeanFactory接口或者是ApplicationContext接口的类的实例，BeanFactory是最顶层、最基本的接口，它描述了容器需要实现的最基本的功能，比如对象的注册、获取等。在编写传统的Java应用代码时，我们一般是直接在对象内部通过new来创建对象，让程序主动去创建依赖对象，这就是一个“谁使用，谁创建”的过程，创建依赖对象的主动权和创建时机都是由自己来把控。
SpringCloud系列（22）--Ribbon默认负载轮询算法原理及源码解析
最新发布
m0_64284147的博客
05-20 267
在上一篇文章中我们介绍了如何去切换Ribbon的负载均衡模式，而本章节内容则是介绍Ribbon默认负载轮询算法的原理。
【Spring Security】授权
weixin_43676950的博客
05-20 400
RBAC（Role-Based Access Control，基于角色的访问控制）是一种常用的数据设计方案，它将用户的权限分配和管理与角色相关联。通过对用户角色关联和角色权限关联表进行操作，可以实现灵活的权限管理和访问控制。1、用户表（User table）：包含用户的基本信息，例如用户名、密码和其他身份验证信息。5、角色权限关联表（Role-Permission table）：将角色与权限关联起来。4、用户角色关联表（User-Role table）：将用户与角色关联起来。
spring 循环依赖
weixin_45849726的博客
05-14 439
先创建ABean1.0. 记录正在创建ABean singletonCurrentlyInCreation<1.1.实例化ABean–>得到一个对象–>存入singletonFactories1.2. 填充BBean属性–>去单例池找BBean–>没有就创建1.3. 进行其他依赖注入1.4. 初始化前，初始化1.5. 初始化后1.6. 放入单例池创建BBean2.1. 实例化BBean–>得到一个对象。
SpringMVC基础
Java小白的博客 致力分享每一天学到的知识
05-15 1305
介绍了有关SpringMVC的基础内容
java云his系统源码 一站式诊所SaaS系统Java+Spring+Angular+Nginx 云HIS系统八大特点
zmm201453的博客
05-15 1213
HIS系统采用面向技术架构的分析与设计方法，应用多层次应用体系架构设计，运用基于构件技术的系统搭建模式与基于组件模式的系统内核结构。通过建立统一接口标准，实现数据交换和集成共享，通过统一身份认证和授权控制，实现业务集成、界面集成。
黑马guli商城项目初始化-SpringCloud微服务项目初始化使用SpringCloudAlibaba快速搭建分布式系统
这个人很懒什么都没有留下
05-16 543
*** 1、如何使用Nacos作为配置中心统一管理配置* 1）、引入依赖，* 2）、创建一个bootstrap.properties。* 3）、需要给配置中心默认添加一个叫 数据集（Data Id）gulimall-coupon.properties。默认规则，应用名.properties* 4）、给 应用名.properties 添加任何配置* 5）、动态获取配置。* @RefreshScope：动态获取并刷新配置* @Value("${配置项的名}")：获取到配置。
SpringBoot事件发布与监听，观察者模式使用
小哇
05-16 213
可以发现，用户注册与信息推送强耦合，用户注册其实到存库成功，就已经算是完成了，后面的信息推送都是额外的操作，甚至信息推送失败报错，还会影响API接口的结果，如果在同一事务，报错信息不捕获，还会导致事务回滚，存库失败。本文记录springboot使用@EventListener监听事件、ApplicationEventPublisher.publishEvent发布事件实现业务解耦。
SpringBoot设置默认文件大小
如果相遇，那么你好哦~
05-14 221
修改SpringBoot项目的默认上传文件大小
spring源码解析第二版pdf
12-28
《Spring源码解析第二版》是一本深入理解Spring框架的重要参考书，该书以全面深入的方式解析了Spring框架的源码。在这本书中，读者可以学习到Spring框架的底层实现原理，以及如何深度定制和扩展Spring框架。 这本书...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值