• JavaEE、Spring

     

    目录

    一、Spring系统架构

    二、核心概念

     三、IoC入门案例

     四、DI入门案例

    五、bean (使用XML配置bean)

    1、基础配置

     2、bean别名配置

     3、bean作用范围

    4、bean的实例化

    1、通过构造器实例化bean

    2、通过静态工厂实例化bean

    3、通过实例工厂实例化bean

    4、通过BeanFactory实例化bean(基于第三种方式改良)(重要！)

    5、bean的生命周期

     六、依赖注入

    1、依赖注入的方式

    1、setter注入

    使用setter注入基本类型

    使用setter注入引用类型

    2、构造器注入

    使用构造器注入引用类型

     使用构造器注入基本类型

    2、依赖注入的方式选择

    3、依赖自动装配

    1、使用类型(byType)自动装配

    2、使用名称(byName)自动装配

     4、集合注入

    5、管理数据源对象

    6、Spring加载properties文件

     七、容器

    1、创建容器

    2、获取bean

    3、ApplicationContext实现类

    八、核心容器、bean与依赖注入总结

    九、注解开发

    1、注解开发定义bean

     2、纯注解开发

      3、注解中bean的管理

    1、bean的作用范围

     2、bean的生命周期

    4、使用注解依赖注入

    1、自动装配

             2、注解加载外部文件

     5、注解中第三方bean的管理

    6、对外部bean依赖注入

    1、注入简单类型

     2、注入引用类型

     7、注解开发总结

    十、Sping整合其他框架

    1、Spring整合MyBatis

    2、Sping整合Junit

    十一、AOP

    1、AOP入门案例

    2、AOP工作流程

    3、AOP切入点表达式

    1、切入点表达式规则

    2、切入点表达式通配符

    3、书写技巧

    4、AOP通知类型(切面注解)

    5、AOP通知获取数据

    6、AOP案例：百度网盘分享链接输入密码AOP处理

    7、AOP总结

     十二、Spring事务

     Spring事务角色

    一、Spring系统架构

    二、核心概念

    当前书写代码存在的问题：业务层中要使用Dao层的实现类就需要new一个实现类对象，如果这时又来一个实现类对象就要修改业务层代码，有需要重新编译测试，代码耦合度极高

     使用IoC控制反转将对象的创建权交给外部，不要再new一个对象

     

     三、IoC入门案例

    2.     <dependency>
    3.       <groupId>org.springframeworkgroupId>
    4.       <artifactId>spring-contextartifactId>
    5.       <version>5.3.16version>
    6.     dependency>
    2.     
    3.     <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" />
    4.  
    5.     <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
    6.         
    7.     bean>
    1. public class BookServiceImpl implements BookService {
    2.    
    3.     private BookDao bookDao = new BookDaoImpl();
    4.  
    5.     @Override
    6.     public void save() {
    7.         System.out.println("bookservice");
    8.         bookDao.save();
    9.     }
    10.  
    11. }

     四、DI入门案例

    由于在service中仍然new了dao的对象才能调用dao方法，没有实现真正解耦

    2.     
    3.     <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" />
    4.  
    5.     <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
    6.         
    7.         
    8.         
    9.         <property name="bookDao" ref="bookDao">property>
    10.     bean>
    1. public class BookServiceImpl implements BookService {
    2.     //仍然new了实现类对象才能进行数据交互
    3.     //private BookDao bookDao = new BookDaoImpl();
    4.  
    5.     //1、删除new的实现类对象
    6.     private BookDao bookDao;
    7.  
    8.     @Override
    9.     public void save() {
    10.         System.out.println("bookservice");
    11.         bookDao.save();
    12.     }
    13.  
    14.     //2、创建setBookDao方法
    15.     public void setBookDao(BookDao bookDao){
    16.         this.bookDao = bookDao;
    17.     }
    18.  
    19. }

    五、bean (使用XML配置bean)

    1、基础配置

     2、bean别名配置

     3、bean作用范围

    可以看到虽然表面创建了两个不同的Dao对象，但他们都指向同一个bean ，所以bean的作用范围默认为单例，因为如果是非单例，每使用一次这个bean都会再重新创建一次这个bean会使得容器中的bean越来越多

     可以通过scope属性设置非单例

    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" scope="prototype"/>

    4、bean的实例化

    1、通过构造器实例化bean

    1. public class BookDaoImpl implements BookDao {
    2.  
    3.     public BookDaoImpl() {
    4.         System.out.println("bookdaoimpl构造器被调用");
    5.     }
    6.  
    7.     @Override
    8.     public void save() {
    9.         System.out.println("bookdao");
    10.     }
    11. }

    可以看到Spring对bean进行实例化会默认通过无参构造器创建bean对象,通过反射实现

    2、通过静态工厂实例化bean

    1. public class BookDaoFactory {
    2.     //创建一个BookDao 工厂，提供创建BookDaoImpl的方法
    3.     public static BookDao getBookDao(){
    4.         System.out.println("factory start");
    5.         return new BookDaoImpl();
    6.     }
    7. }
    1.     
    2.     <bean id="bookDao" class="com.itheima.factory.BookDaoFactory" factory-method="getBookDao">bean>

    3、通过实例工厂实例化bean

    1. public class BookDaoFactory2 {
    2.     //创建实例工厂
    3.     public BookDao getBookDao(){
    4.         System.out.println("实例工厂被调用");
    5.         return new BookDaoImpl();
    6.     }
    7. }
    2.     <bean id="BookFactory" class="com.itheima.factory.BookDaoFactory2">bean>
    3.     
    4.     <bean id="bookDao" factory-method="getBookDao" factory-bean="BookFactory">bean>

    4、通过BeanFactory实例化bean(基于第三种方式改良)(重要！)

    1. //实现FactoryBean接口，声明泛型类型，可能还有其他的bean需要实例化只需要修改泛型类型即可
    2. public class BookFactoryBean implements FactoryBean {
    3.  
    4.     @Override
    5.     public BookDao getObject() throws Exception {
    6.         System.out.println("factorybean 启动");
    7.         //返回BookDao的实现类
    8.         return new BookDaoImpl();
    9.     }
    10.  
    11.     @Override
    12.     public Class getObjectType() {
    13.         //声明返回对象的类型
    14.         return BookDao.class;
    15.     }
    16.  
    17.     @Override
    18.     public boolean isSingleton() {
    19.         //此处为true说明实例化的对象为单例(同一个bean)，false为非单例
    20.         return true;
    21.     }
    22. }
    3. <bean id="bookDao" class="com.itheima.factory.BookFactoryBean">bean>

    5、bean的生命周期

     六、依赖注入

    1、依赖注入的方式

    1、setter注入

    上节bean的实例化都是使用setter注入的方式进行

    • 使用setter注入基本类型

    1. public class BookServiceImpl2 implements BookService {
    2.     //使用setter注入 注入基本类型
    3.     private int maxLink;
    4.     private String databaseName;
    5.  
    6.     public void setMaxLink(int maxLink) {
    7.         this.maxLink = maxLink;
    8.     }
    9.  
    10.     public void setDatabaseName(String databaseName) {
    11.         this.databaseName = databaseName;
    12.     }
    13.  
    14.     public void save() {
    15.         System.out.println("bookservice被创建");
    16.         System.out.println(maxLink +"..."+ databaseName);
    17.     }
    18. }
    1. <bean id="bookService2" class="com.itheima.service.impl.BookServiceImpl2">
    2.         
    3.         <property name="maxLink" value="10"/>
    4.         <property name="databaseName" value="uesr"/>
    5.     bean>

    • 使用setter注入引用类型

    1. public class BookServiceImpl implements BookService {
    2.     private BookDao bookDao;
    3.     private UserDao userDao;
    4.  
    5.     
    6.     //创建set方法
    7.     public void setBookDao(BookDao bookDao) {
    8.         this.bookDao = bookDao;
    9.     }
    10.  
    11.     public void setUserDao(UserDao userDao) {
    12.         this.userDao = userDao;
    13.     }
    14.  
    15.     public void save() {
    16.         System.out.println("bookservice被创建");
    17.         bookDao.save();
    18.         userDao.save();
    19.     }
    20. }
    2.     <bean id="bookdao" class="com.itheima.dao.impl.BookDaoImpl">bean>
    3.  
    4.     <bean id="userdao" class="com.itheima.dao.impl.UserDaoImpl">bean>
    5.  
    6.     <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
    7.         
    8.         <property name="bookDao" ref="bookdao">property>
    9.         <property name="userDao" ref="userdao">property>
    10.     bean>

    2、构造器注入

    • 使用构造器注入引用类型

    1. public class BookServiceImpl3 implements BookService {
    2.     //使用setter注入 注入基本类型
    3.     private BookDao bookDao1;
    4.     private UserDao userDao1;
    5.  
    6.     //使用构造器注入，设置构造器参数
    7.     public BookServiceImpl3(BookDao bookDao1,UserDao userDao1) {
    8.         this.bookDao1 = bookDao1;
    9.         this.userDao1 = userDao1;
    10.     }
    11.  
    12.     public void save() {
    13.         System.out.println("bookservice被创建");
    14.         bookDao1.save();
    15.         userDao1.save();
    16.     }
    17. }
    1.   <bean id="bookService3" class="com.itheima.service.impl.BookServiceImpl3">
    2.         
    3.         <constructor-arg name="bookDao1" ref="bookdao"/>
    4.         <constructor-arg name="userDao1" ref="userdao"/>
    5.     bean>

    •  使用构造器注入基本类型

    仅仅修改配置文件中的ref  化成value

    但是当前构造器注入仍然存在紧耦合的问题，参数名一旦发生改变配置文件就要相对应的改变

    所以Spring给出了解决方案

    1.  <bean id="bookService3" class="com.itheima.service.impl.BookServiceImpl3">
    2.         
    3.         <constructor-arg type="com.itheima.dao.BookDao" ref="bookdao"/>
    4.         <constructor-arg type="com.itheima.dao.UserDao" ref="userdao"/>
    5.     bean>

    但是使用这种方式也可能会出现参数类型相同的情况所以又引出了第二种解决方案

    1. <bean id="bookService3" class="com.itheima.service.impl.BookServiceImpl3">
    2.         
    3.         <constructor-arg index="0" ref="bookdao"/>
    4.         <constructor-arg index="1" ref="userdao"/>
    5.     bean>

    2、依赖注入的方式选择

    构造器注入是必须注入的，而setter注入是可选的可注可不注

    3、依赖自动装配

    1、使用类型(byType)自动装配

    2、使用名称(byName)自动装配

    2.     
    3.     <bean id="bookService4" class="com.itheima.service.impl.BookServiceImpl4" autowire="byName"/>
    1. public class BookServiceImpl4 implements BookService {
    2.     //使用setter注入 注入基本类型
    3.     private BookDao bookDao;
    4.     private UserDao userDao;
    5.  
    6.     //使用setter方法设置自动装配入口
    7.     public void setBookDao(BookDao bookDao) {
    8.         this.bookDao = bookDao;
    9.     }
    10.  
    11.     public void setUserDao(UserDao userDao) {
    12.         this.userDao = userDao;
    13.     }
    14.  
    15.     public void save() {
    16.         System.out.println("bookservice被创建");
    17.         bookDao.save();
    18.         userDao.save();
    19.     }
    20. }

     

     4、集合注入

     

     如果集合中要加入引用类型的数据将value改为ref

    5、管理数据源对象

    用IoC容器来管理外部导入的资源，例如druid数据库连接池，junit测试等依赖

    1.  
    2.     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    3.         
    4.         <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    5.         <property name="url" value="jdbc:mysql://localhost:3306"/>
    6.         <property name="username" value="123"/>
    7.         <property name="password" value="123"/>
    8.     bean>

    6、Spring加载properties文件

    1.  
    3. <beans xmlns="http://www.springframework.org/schema/beans"
    4.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    5.  
    6.        xmlns:context="http://www.springframework.org/schema/context"
    7.  
    8.        xsi:schemaLocation="http://www.springframework.org/schema/beans
    9.                            http://www.springframework.org/schema/beans/spring-beans.xsd
    10.                            http://www.springframework.org/schema/context
    11.                            http://www.springframework.org/schema/context/spring-context.xsd">
    12.  
    13.     
    14.     
    15.     <context:property-placeholder location="jdbc.properties" system-properties-mode="NEVER"/>
    16.  
    17.     
    18.     <bean class="com.alibaba.druid.pool.DruidDataSource">
    19.         <property name="driverClassName" value="${jdbc.driverClassName}"/>
    20.         <property name="url" value="${jdbc.url}"/>
    21.         <property name="username" value="${jdbc.username}"/>
    22.         <property name="password" value="${jdbc.password}"/>
    23.     bean>
    24.  
    25.  
    26. beans>

     

     七、容器

    1、创建容器

    1. //1、使用类路径创建容器
    2.         ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    3.         //2、使用文件系统绝对路径创建容器
    4.         ApplicationContext ctx = new FileSystemXmlApplicationContext("D:\\2ProgramTool\\JavaEETest\\stage1\\springdemo3\\src\\main\\resources\\jdbc.properties");

    2、获取bean

    3、ApplicationContext实现类

    ApplicationContext的祖宗接口就是BeanFactory

    八、核心容器、bean与依赖注入总结

     

     

    九、注解开发

    1、注解开发定义bean

     2、纯注解开发

     使用纯注解定义bean

    1.  
    2. //1、创建配置类代替配置文件
    3. @Configuration //代表配置文件
    4. @ComponentScan("com.itheima") //代表包扫描组件
    5. @ComponentScan({"com.itheima","com.ittest"}) //在多个包扫描组件
    6. public class SpringConfig {
    7.     //使用配置类代替配置文件
    8. }
    1. //2、定义bean
    2. @Repository("bookDao")
    3. public class BookDaoImpl implements BookDao {
    4.  
    5.     public void save() {
    6.         System.out.println("注解开发");
    7.     }
    8. }
    1. //3、使用bean
    2. public class App {
    3.     public static void main(String[] args) {
    4.  
    5.         //使用纯注解开发将不再需要applicatinContext文件
    6.         ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
    7.         //通过组件名称
    8.         BookDao bookDao = ctx.getBean("bookDao", BookDao.class);
    9.         System.out.println(bookDao);
    10.     }
    11. }

    3、注解中bean的管理

    1、bean的作用范围

     2、bean的生命周期

    4、使用注解依赖注入

    1、自动装配

    注入引用类型

    1. @Repository("bookDao")
    2. public class BookDaoImpl implements BookDao {
    3.  
    4.     @Autowired  //默认按类型自动装配，不需要写setter入口
    5.     @Qualifier("mappDao") //按名称装配
    6.     private Mapp mapp;
    7.  
    8.     public void save() {
    9.         System.out.println("bookDao被创建");
    10.         mapp.save();
    11.     }
    12. }

     注入基本类型

     2、注解加载外部文件

     5、注解中第三方bean的管理

    1. @Configuration //代表配置文件
    2. @ComponentScan("com.itheima") //代表扫描组件
    3. @PropertySource({"jdbc.properties","jdbc2.properties","jdbc3.properties","jdbc2-1.properties"})
    4. public class SpringConfig {
    5.     //使用配置类代替配置文件
    6.     
    7.     @Bean  //说明返回类型是一个bean
    8.     public DataSource dataSource(){
    9.         DruidDataSource ds = new DruidDataSource();
    10.         ds.setDriverClassName("com.mysql.jdbc.Driver");
    11.         ds.setUrl("jdbc:mysql://localhost:3306/spring_db");
    12.         ds.setName("root");
    13.         ds.setPassword("root");
    14.         return ds;
    15.     }
    16. }

    在实际开发中，外部的bean一般另外创建一个类来创建bean，然后导入的方式加到配置文件中

    1. //1、单独创建一个类
    2. public class JdbcConfig {
    3.     @Bean  //说明返回类型是一个bean
    4.     public DataSource dataSource(){
    5.         DruidDataSource ds = new DruidDataSource();
    6.         ds.setDriverClassName("com.mysql.jdbc.Driver");
    7.         ds.setUrl("jdbc:mysql://localhost:3306/spring_db");
    8.         ds.setName("root");
    9.         ds.setPassword("root");
    10.         return ds;
    11.     }
    12. }
    1. @Configuration //代表配置文件
    2. @Import(JdbcConfig.class) //导入外部bean 多个外部bean使用数组形式
    3. public class SpringConfig {
    4.     //使用配置类代替配置文件
    5.  
    6. }

    6、对外部bean依赖注入

    1、注入简单类型

     2、注入引用类型

    直接设置参数，会进行自动装配

     7、注解开发总结

    十、Sping整合其他框架

    1、Spring整合MyBatis

    导入坐标

    1.   
    2.   <dependency>
    3.     <groupId>org.springframeworkgroupId>
    4.     <artifactId>spring-jdbcartifactId>
    5.     <version>5.3.16version>
    6.   dependency>
    7.   <dependency>
    8.     <groupId>org.mybatisgroupId>
    9.     <artifactId>mybatis-springartifactId>
    10.     <version>1.3.0version>
    11.   dependency>

     创建jdbc.properties外部文件

    1. driver=com.mysql.jdbc.Driver
    2. url=jdbc:mysql://localhost:3306/users?useSSL=false
    3. username=root
    4. password=12345

    设置数据源 jdbc连接数据库

    1. public class JdbcConfig {
    2.     @Value("${driver}")
    3.     private String driverClassName;
    4.     @Value("${url}")
    5.     private String url;
    6.     @Value("${name}")
    7.     private String name;
    8.     @Value("${password}")
    9.     private String password;
    10.  
    11.     @Bean
    12.     public DataSource dataSource(){
    13.         //创建jdbc的数据库连接池DataSource
    14.         DruidDataSource ds = new DruidDataSource();
    15.         ds.setDriverClassName(driverClassName);
    16.         ds.setUrl(url);
    17.         ds.setName(name);
    18.         ds.setPassword(password);
    19.         return ds;
    20.     }
    21. }

    配置类 

    1. @Configuration
    2. @ComponentScan("com.itheima")
    3. @PropertySource("jdbc.properties")
    4. @Import({JdbcConfig.class,MyBatisConfig.class})
    5. public class SpringConfig {
    6. }

    2、Sping整合Junit

     导入坐标

    2.     <dependency>
    3.       <groupId>org.springframeworkgroupId>
    4.       <artifactId>spring-testartifactId>
    5.       <version>5.3.16version>
    6.     dependency>
    7.     <dependency>
    8.       <groupId>junitgroupId>
    9.       <artifactId>junitartifactId>
    10.       <version>4.12version>
    11.       <scope>testscope>
    12.     dependency>

     使用专用类运行器RunWith

    1. @RunWith(SpringJUnit4ClassRunner.class)
    2. //与配置类接通
    3. @ContextConfiguration(classes = SpringConfig.class)
    4. public class ServiceTest {
    5.  
    6.     @Autowired
    7.     private AccountService accountService;
    8.  
    9.     @Test
    10.     public void testSelectById(){
    11.         System.out.println(accountService.selectById(2));
    12.     }
    13. }

    十一、AOP

    1、AOP入门案例

     导入需要的坐标

    在导入spring-context时是默认自动导入aop的坐标

    1.   <dependencies>
    2.     <dependency>
    3.       <groupId>org.springframeworkgroupId>
    4.       <artifactId>spring-contextartifactId>
    5.       <version>5.3.16version>
    6.     dependency>
    7.  
    8.     <dependency>
    9.       <groupId>org.aspectjgroupId>
    10.       <artifactId>aspectjweaverartifactId>
    11.       <version>1.9.4version>
    12.     dependency>
    13.   dependencies>
    1. //6、创建bean
    2. @Component
    3. //7、将这个bean作为AOP处理
    4. @Aspect
    5. public class MyAdvice {
    6.     //2、创建通知类 定义通知方法
    7.  
    8.     //4、定义切入点
    9.     @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    10.     private void pt(){}
    11.     
    12.     //5、设置切入点的位置，作为切面绑定通知与切入点的关系
    13.     @Before("pt()")
    14.     public void advice(){
    15.         //3、共性方法  通知
    16.         System.out.println(System.currentTimeMillis());
    17.     }
    18.  
    19. }
    1. @Configuration
    2. @ComponentScan("com.itheima")
    3. //8、启动Aspect注解，开启AOP代理自动配置
    4. @EnableAspectJAutoProxy
    5. public class SpringConfig {
    6. }

    2、AOP工作流程

    底层是代理模式增强功能

     

    3、AOP切入点表达式

    1、切入点表达式规则

     

    2、切入点表达式通配符

     

    3、书写技巧

     

    4、AOP通知类型(切面注解)

     

    1.     @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    2.     private void pt(){}
    3.     @Pointcut("execution(int com.itheima.dao.BookDao.select())")
    4.     private void pt2(){}
    5.  
    6.     //1、前置通知
    7. //    @Before("pt()")
    8.     public void advice(){
    9.         System.out.println("before is running...");
    10.     }
    11.  
    12.     //2、后置通知
    13. //    @After("pt()")
    14.     public void after(){
    15.         System.out.println("after is running...");
    16.     }
    17.     //3、环绕通知
    18.     @Around("pt2()")
    19.     public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
    20.         System.out.println("before running...");
    21.         //调用原始方法
    22.         //Object proceed = joinPoint.proceed();
    23.         //还要将原始方法的返回值返回出去
    24.         Integer proceed = (Integer) joinPoint.proceed();
    25.  
    26.         System.out.println("after  running...");
    27.         //还可以对原始方法的返回值进行修改
    28.         return proceed;
    29.     }

    5、AOP通知获取数据

    获取原始方法的参数数组，可以对参数进行修改，注意如果使用了JoinPoint作为参数一定要放在参数最前面。

     6、AOP案例：百度网盘分享链接输入密码AOP处理

     

    1. @Component
    2. @Aspect
    3. public class BaiduAop {
    4.  
    5.     @Pointcut("execution(boolean com.itheima.service.*Service.judgement(*,*))")
    6.     public void pt(){}
    7.  
    8.  
    9.     @Around("BaiduAop.pt()")
    10.     public Object trimStr(ProceedingJoinPoint pjp) throws Throwable {
    11.  
    12.         //获取参数数据
    13.         Object[] args = pjp.getArgs();
    14.         //对参数数组遍历，对字符串类型的参数进行trim处理
    15.         for (int i = 0; i < args.length; i++) {
    16.             if (args[i].getClass().equals(String.class)){
    17.                 //如果是字符串就处理并修改参数
    18.                 args[i] = args[i].toString().trim();
    19.             }
    20.         }
    21.         //将修改后的参数再传递给原始函数
    22.         Object proceed = pjp.proceed(args);
    23.         return proceed;
    24.  
    25.     }
    26. }

    7、AOP总结

     

     十二、Spring事务

     

     

     

     

     Spring事务角色

     

  • 相关阅读:
    如何安装ubuntu22.04以及ubuntu各个版本配置国内源和ssh远程登录
    如何在 swgger 中设置连接前后端的 API 接口
    Navicat15工具连接PostgreSQL15失败
    聊一聊 golang 的测试与性能调优
    关于在线音乐软件设计与实现的答辩问题
    德克萨斯大学奥斯汀分校自然语言处理硕士课程汉化版(第八周) - 现代大语言模型
    365天挑战LeetCode1000题——Day 035 每日一题 + 二分查找 13
    计算机毕业设计Java网上投稿管理系统（源码+系统+mysql数据库+Lw文档）
    8条IM即时通讯开发iOS端移动网络调优建议
    微服务学习|Feign:快速入门、自定义配置、性能优化、最佳实践
  • 原文地址：https://blog.csdn.net/m0_56044262/article/details/126636830