spring

IOC

xml1 https://blog.csdn.net/weixin_45496190/article/details/107059038

xml2 https://blog.csdn.net/weixin_45496190/article/details/107067200

注解 https://blog.csdn.net/weixin_45496190/article/details/107071204

工厂模式思想：使用工厂类来提供对象，降低耦合性。

springIOC：在工厂模式中使用xml解析、反射的方式创建对象，进一步降低耦合性。

Spring提供的IOC容器实现的两种方式（两个接口）

BeanFactory   加载xml文件不会创建对象，在使用对象时才会创建

ApplicationContext  加载配置文件时就会把配置文件的所有对象进行创建

对比：开发使用ApplicationContext ，在服务器启动时可以创建所有对象，提高运行时性能

DI:依赖注入

• 有参构造

• set方法

• 名称空间注入（了解）

CDATA方式注入特殊符号 ： <![CDATA[特殊符号]]>

内部bean、外部bean

集合、数组类型注入；

​ 、、

集合提取

工厂bean：在配置文件定义 bean 类型可以和返回类型不一样 第一步 创建类，让这个类作为工厂 bean，实现接口 FactoryBean 第二步 实现接口里面的方法，在实现的方法中定义返回的 bean 类型

bean作用域：

// 在 Spring 里面，默认情况下，bean 是单实例对象，下面进行作用域设置：
（1）在 spring 配置文件 bean 标签里面有属性（scope）用于设置单实例还是多实例

（2）scope 属性值 第一个值 默认值，singleton，表示是单实例对象 第二个值 prototype，表示是多实例对象,在调用 getBean 方法时候才创建多对象

bean生命周期：

（1）通过构造器创建 bean 实例（无参数构造）

（2）为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）

（3）把 bean 实例传递 bean 后置处理器的方法 postProcessBeforeInitialization

（4）调用 bean 的初始化的方法（需要进行配置初始化的方法）

（5）把 bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization

（6）bean 可以使用了（对象获取到了）

（7）当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

自动装配

Spring自动装配，不需要使用property标签,使用autowire属性，配置自动装配 autowire：byname按属性名称注入，bytype按属性类型注入 （1）byname 注入的bean的id值与类属性名称要一样 （2）byType在一个xml中不能有同类型的bean，所以用的少

外部属性文件生成数据库连接池对象

（1）创建外部属性文件，properties 格式文件，写数据库信息
（2）把外部 properties 属性文件引入到 spring 配置文件中 —— 引入 context 名称空间

注解开发

• 创建bean实例的四个注解

@Component
@Service
@Controller
@Repository

基于注解方式实现对象创建

第一步 引入依赖 （引入spring-aop jar包）

第二步 xml中开启组件扫描(注解扫描) 配置 //详细配置在上面链接

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

基于注解方式实现属性注入

//不需要set方法
@Autowired：根据属性类型进行自动装配;
/*
@Autowired
@Qualifier(value='userDaoImpl')
*/
@Qualifier：根据名称进行注入，这个@Qualifier 注解的使用，和上面@Autowired 一起使用;
/*
@Resource   根据类型注入
@Resource(name = "userDaoImpl1")   根据名称注入
*/
@Resource：可以根据类型注入，也可以根据名称注入（它属于javax包下的注解，不推荐使用！）

完全注解开发

创建配置类，替代 xml 配置文件

@Configuration //作为配置类，替代 xml 配置文件
@ComponentScan(basePackages = {"com.atguigu"})  //扫描路径  可以用数组
public class SpringConfig {
    
}
//BeanFactory、ApplicationContext  是加载xml 生成ioc容器
//此处需要用AnnotationConfigApplicationContext类来加载配置类生成ioc容器  AnnotationConfigApplicationContext(配置类.class);

Spring-AOP

aop底层原理

底层使用动态代理，动态代理有两种情况

• jdk动态代理(有接口的情况)

  创建接口实现类代理对象，使用Proxy类的静态方法

  public static Object newProxyInstance(ClassLoader loader,
                                        Class<?>[] interfaces,
                                        InvocationHandler h){};
  //参数1 创建代理对象的类的类加载器
  //参数2 增强类实现的接口，可以是多个
  //参数3 InvocationHandler接口的实现类对象，其中包含被代理的对象以及增强的逻辑
  

• cglib动态代理(无接口的情况)

  创建子类的代理对象

AOP（术语）

a）连接点：类里面哪些方法可以被增强，这些方法称为连接点

b）切入点：实际被真正增强的方法称为切入点

c）通知（增强）：实际增强的逻辑部分称为通知，且分为以下五种类型：

1）前置通知 2）后置通知 3）环绕通知 4）异常通知 5）最终通知

d）切面：把通知应用到切入点过程

AOP操作

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

半注解进行aop配置

1. xml配置

<!--3、进行通知的配置-->
<?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">

    <!-- 开启注解扫描 -->
    <context:component-scan base-package="com.atguigu.spring5.aopanno"></context:component-scan>

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

2.被增强的类交给ioc容器管理

//被增强的类
@Component
public class User {}

3.增强类

//4、配置不同类型的通知
@Component
@Aspect  //生成代理对象
@Order(1)//多个增强类优先级设置,值越小优先级愈高
public class UserProxy {
      //相同切入点抽取
    @Pointcut(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void pointdemo() {

    }

    //前置通知
    @Before(value = "pointdemo()")//相同切入点抽取使用！不抽取时使用切入点表达式
    public void before() {
        System.out.println("before.........");
    }

    //后置通知（返回通知）
    @AfterReturning(value = "pointdemo()")
    public void afterReturning() {
        System.out.println("afterReturning.........");
    }

    //最终通知
    @After(value = "pointdemo()")
    public void after() {
        System.out.println("after.........");
    }

    //异常通知
    @AfterThrowing(value = "pointdemo()")
    public void afterThrowing() {
        System.out.println("afterThrowing.........");
    }

    //环绕通知
    @Around(value = "pointdemo()")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前.........");

        //被增强的方法执行
        proceedingJoinPoint.proceed();

        System.out.println("环绕之后.........");
    }
}

xml配置切入点、切面、通知

<!--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>

以上两种方式使用ClassPathXmlApplicationContext类来获取被增强的类的对象

全注解(使用配置类)

JdbcTemplate

1. spring配置文件配置数据库连接池

   <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
    destroy-method="close">
    <property name="url" value="jdbc:mysql:///test" />
    <property name="username" value="root" />
    <property name="password" value="root" />
    <property name="driverClassName" value="com.mysql.jdbc.Driver" />
   </bean>
   

2. 配置 JdbcTemplate 对象，注入 DataSource

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

3. 创建 service 类，创建 dao 类，在 dao 注入 jdbcTemplate 对象

   注意：开启注解扫描

   //使用jdbcTemplate 的update 方法实现增删改

   String sql = "insert into t_book values(?,?,?)";
   Object[] args = {book.getUserId(), book.getUsername(),book.getUstatus()};
   int update = jdbcTemplate.update(sql,args);
   

   //查询对象使用queryForObject方法

   //查询对象使用queryForObject方法
   
   String sql = "select count(*) from t_book";
   //queryForObject方法中：第一个参数代表--sql语句；第二个参数代表--返回类型class  
    Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
   ------------------------------------------------------------------------------
   String sql = "select * from t_book where user_id=?";
   /*
   	queryForObject方法中：
   		第一个参数：sql语句
   		第二个参数：RowMapper 是接口，针对返回不同类型数据，使用这个接口里面 实现类 完成数据封装
   		第三个参数：sql 语句值
   */
    Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class), id);
   

   查询返回对象list

   String sql = "select * from t_book";
    //调用方法
    List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
   

   批量增删改

    String sql = "insert into t_book values(?,?,?)";
   //batchUpdate方法 第一个参数：sql语句		第二个参数：List<Object[]>集合，添加多条记录数据
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
   

Spring——事务操作

1、事务添加到 JavaEE 三层结构里面 Service 层（业务逻辑层）

2、在 Spring 进行事务管理操作 ；两种方式：编程式事务管理、声明式事务管理（推荐使用）

3、声明式事务管理 （1）基于注解方式（推荐使用） （2）基于 xml 配置文件方式

4、在 Spring 进行声明式事务管理，底层使用 AOP 原理

5、Spring 事务管理 API ：提供一个接口，代表事务管理器，这个接口针对不同的框架提供不同的实现类

注解声明式事务管理

xml配置

 <!--2、在 spring 配置文件，开启事务注解,引入名称空间！-->
<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"
 xmlns:tx="http://www.springframework.org/schema/tx"
 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 
 http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">

<!--1、在 spring 配置文件配置事务管理器-->
//创建事务管理器 DataSourceTransactionManager为jdbcTemplate和mybatis的事务管理器
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
 <!--注入数据源-->
 <property name="dataSource" ref="dataSource"></property>
</bean>

<!--开启事务注解-->
<tx:annotation-driven transactionmanager="transactionManager"></tx:annotation-driven>
 <!--3、在 service 类上面（或者 service 类里面方法上面）添加事务注解-->
 <!--
    （1）@Transactional，这个注解添加到类上面，也可以添加方法上面
    （2）如果把这个注解添加类上面，这个类里面所有的方法都添加事务
    （3）如果把这个注解添加方法上面，为这个方法添加事务——@Transactional
	-->

@Transactional属性

• propagation

  事务传播行为，有七种。常用的为

  • REQUIRED：如果方法本身有事务，调用事务方法后，被调用方法使用当前方法里面的事务；如果方法本身没有事务，调用事务方法后，创建新的事务

  • REQUIRED_NEW：调用事务方法，不论当前方法是否有事务，都会创建新的事务。

• ioslation

• timeout

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

• readOnly 是否只读

  readOnly 默认值 false，表示可以查询，可以添加修改删除操作

• rollbackFor

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

• noRollbackFor

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

默认状态@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ)

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.atguigu.spring5.service.UserService.*(..))"/>
 <!--配置切面-->
 <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
</aop:config>

完全注解声明式事务

//1、创建配置类，使用配置类替代 xml 配置文件
@Configuration //配置类
@ComponentScan(basePackages = "com.atguigu") //组件扫描
@EnableTransactionManagement //开启事务
public class TxConfig {
 //创建数据库连接池
 @Bean
 public DruidDataSource getDruidDataSource() {
 DruidDataSource dataSource = new DruidDataSource();
 dataSource.setDriverClassName("com.mysql.jdbc.Driver");
 dataSource.setUrl("jdbc:mysql:///test");
 dataSource.setUsername("root");
 dataSource.setPassword("root");
 return dataSource;
 }
 //创建 JdbcTemplate 对象
 @Bean
 public JdbcTemplate getJdbcTemplate(DataSource dataSource) {//从IOC容器中拿到配置注入的数据源
 //到 ioc 容器中根据类型找到 dataSource,类似于@autowire的注入方式
 JdbcTemplate jdbcTemplate = new JdbcTemplate();
 //注入 dataSource
 jdbcTemplate.setDataSource(dataSource);
 return jdbcTemplate;
 }
 //创建事务管理器
 @Bean
 public DataSourceTransactionManager
getDataSourceTransactionManager(DataSource dataSource) {
 DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
 transactionManager.setDataSource(dataSource);
 return transactionManager;
 }
}

//@Bean注解：表示方法返回一个bean，并交给ioc容器管理