【SSM基础知识2】spring2

wishkejdn

已于 2023-03-20 09:21:00 修改

阅读量89

点赞数

文章标签： java spring

于 2023-03-13 17:22:56 首次发布

本文链接：https://blog.csdn.net/zsxdcsdfg/article/details/129492732

版权

Spring 配置非自定义Bean

1.配置Druid 数据源交由Spring管理
（1）导入Druid坐标

        <!-- mysql 驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.32</version>
        </dependency>
        <!-- druid数据源-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.16</version>
        </dependency>

（2）配置数据源信息

<!--配置数据源信息-->
<bean id="dataSource class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://localhost:3306/mybatis"></property>
    <property name="username" value="root"></property>
    <property name="password" value="root"></property>
</bean>

3.测试

public static void main(String[] args){
    ClassPathXmlApplicationContext applicationContext= new ClassPathXmlApplicationContext();
    applicationContext.getBean( name:"dataSource");
    System.out.println(dataSource);
    }
}

2. 配置Connection交由Spring管理
Connection的产生是通过DriverManager的静态方法getConnection获取的，所以我们要用静态工厂方式配置

<bean class="java.lang.Class" factory-method="forName">
    <constructor-arg name="className" value="com.mysql.jdbc.Driver"/>
</bean>
<bean id="connection" class="java.sql.DriverManager" factory-method="getConnection" scope="prototype">
    <constructor-arg name="url" value="jdbc:mysql:///mybatis"/>
    <constructor-arg name="user" value="root"/>
    <constructor-arg name="password" value="root"/>
</bean>

3.配置日期对象交由Spring管理
产生一个指定日期格式的对象，原始代码如下：

String currentTimeStr ="2023-08-27 07:20:00";
SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

Date date = simpleDateFormat.parse(currentTimeStr);

可以看成是实例工厂方式，使用Spring配置方式产生Date实例

<bean id="simpleDateFormat" class="java.text.SimpleDateFormat">
     <constructor-arg name="pattern" value="yyyy-MM-dd HH:mm:ss"/>
</bean>
<bean id="date" factory-bean="simpleDateFormat" factory-method="parse"> 
      <constructor-arg name="source" value="2023-08-27 07:20:00"/>
</bean>

4.配置MyBatis的SqlSessionFactory交由Spring管理
（1）导入MyBatis的相关坐标：

        <!--mybatis框架-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.9</version>
        </dependency>
        <!-- mysql驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.32</version>
        </dependency>

//静态工厂方法方式
InputStream in =Resources.getResourceAsStream("mybatis-config.xml"); 
//无参构造实例化
SqlSessionFactoryBuilder builder=new SqlSessionFactoryBuilder();
//实例工厂方法
SqlSessionFactory  sqlSessionFactory= builder.build(in);

<!--静态工厂方法方式-->
<bean id="in" class="org.apache.ibatis.io.Resources" factory-method="getResouse>
     <constructor-arg name="resource" value="mybatis-config.xml"></constructor-arg> 
</bean>
<!--无参构造实例化--> 
<bean id="builder" class="org.apache.ibatis.session.SqlSessionFactoryBuilder>
<!--实例工厂方法-->
<bean id="sqlSessionFactory" factory-bean="builder" factory-method="build>
      <constructor-arg name="inputStream" ref="in"></constructor-arg> 
</bean>

Spring的后处理器

Spring的后处理器是Spring对外开发的重要扩展点，允许我们介入到Bean的整个实例化流程中来，以达到动态注册BeanDefinition，动态修改BeanDefinition，以及动态修改Bean的作用。Spring主要有两种后处理器：
●BeanFactoryPostProcessor：Bean工厂后处理器，在BeanDefinitionMap填充完毕，Bean实例化之前执行；
●BeanPostProcessor：Bean后处理器，一般在Bean实例化之后，填充到单例池singletonObjects之前执行。

Bean工厂后处理器——BeanFactoryPostProcessor
BeanFactoryPostProcessor是一个接口规范，实现了该接口的类只要交由Spring容器管理的话，那么Spring就会回调该接口的方法，用于对BeanDefinition注册和修改的功能。

BeanFactoryPostProcessor定义如下：

public interface BeanFactoryPostProcessor {
     void postProcessBeanFactory(ConfigurableListableBeanFactorybean Factory);
}

Spring提供了一个BeanFactoryPostProcessor的子接口BeanDefinitionReqistryPostProcessor专门用于注册BeanDefinition操作

public class MyBeanFactoryPostProcessor implements BeanDefinitionRegistryPostProcessor{

    @Override 
    public void postProcessBeanFactory(ConfigurableListableBeanFactory confiqurableListableBeanFactory) throws BeansException (){}
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
    BeanDefinition beanDefinition = new RootBeanDefinition();
    beanDefinition.setBeanClassName("com.ting.dao.UserDaoImpl2");
    beanDefinitionRegistry.registerBeanDefinition("userDao2",beanDefinition);

    }
}

Spring Bean的生命周期

Spring Bean的生命周期是从 Bean 实例化之后，即通过反射创建出对象之后，到Bean成为一个完整对象，最终存储到单例池中，这个过程被称为SpringBean的生命周期。SpringBean的生命周期大体上分为三个阶段：
♡Bean的实例化阶段：Spring框架会取出BeanDefinition的信息进行判断当前Bean的范围是否是singleton的，是否不是延迟加载的，是否不是FactoryBean等，最终将一个普通的singleton的Bean通过反射进行实例化；
♡Bean的初始化阶段：Bean创建之后还仅仅是个"半成品"，还需要对Bean实例的属性进行填充、执行一些Aware接口方法、执行BeanPostProcessor方法、执行InitializingBean接口的初始化方法、执行自定义初始化init方法等。
♡Bean的完成阶段：经过初始化阶段，Bean就成为了一个完整的Spring Bean，被存储到单例池
singletonObjects中去了，即完成了Spring Bean的整个生命周期。

Spring Bean的初始化过程涉及如下几个过程：
1)Bean实例的属性填充
2)Aware接口属性注入
3)BeanPostProcessor的before() 方法回调
4)InitializingBean接口的初始化方法回调，自定义初始化方法init()回调，BeanPostProcessor的after()方法回调

⊙Bean实例属性填充
Spring在进行属性注入时，会分为如下几种情况：
1）注入普通属性，String、int或存储基本类型的集合时，直接通过set方法的反射设置进去
2）注入单向对象引用属性时，从容器中getBean获取后通过set方法反射设置进去，如果容器中没有，则先创建被注入对象Bean实例（完成整个生命周期）后，在进行注入操作；
3）注入双向对象引用属性时，就比较复杂了，涉及了循环引用（循环依赖）问题

多个实体之间相互依赖并形成闭环的情况就叫做"循环依赖”，也叫做“循环引用”

public class UserServiceImpl implements UserService{
     public void setUserDao(UserDao userDao) {}
}
public class UserDaoImpl implements UserDao{
          public void setUserService(UserService userService){}
}

<bean id="userService" class="com.ting.service.impl.UserserviceImpl">
      <property name="userDao" ref="userDao"/>
</bean>
<bean id="userDao" class="com.ting.dao.impl.UserDaoImpl">
  <property name="userService" ref="userService"/>
</bean>

Spring提供了三级缓存存储完整Bean实例和半成品Bean实例，用于解决循环引用问题
在DefaultListableBeanFactory的上四级父类DefaultSingletonBeanRegistry中提供如下三个Map:

public class DefaultsingletonBeanRegistry...{
    //1、最终存储单例Bean成品的容器，即实例化和初始化都完成的Bean，称之为"一级缓存”
    Map<StringObject> singletonObjects= new ConcurrentHashMap(256);
    //2、早期Bean单例池，缓存半成品对象，且当前对象已经被其他对象引用了，称之为“二级缓存”
    Map<String,Object> earlySingletonObjects =new ConcurrentHashMap(16);
    //3、单例Bean的工厂池，缓存半成品对象，对象未被引用，使用时在通过工厂创建Bean，称之为“三级缓存”
    Map<String,ObjectFactory<?>> singletonFactories= new HashMap(16);
}

UserService和UserDao循环依赖的过程

●UserService实例化对象，但尚未初始化，将UserService存储到三级缓存；
●UserService属性注入，需要UserDao，从缓存中获取，没有UserDao；
●UserDao实例化对象，但尚未初始化，将UserDao存储到到三级缓存；
●UserDao属性注入，需要UserService，从三级缓存获取UserService，UserService从三级缓存移入二级

●缓存UserDao执行其他生命周期过程，最终成为一个完成Bean，存储到一级缓存，删除二三级缓存；

●UserService 注入UserDao;
●UserService执行其他生命周期过程，最终成为一个完成Bean，存储到一级缓存，删除二三级缓存。

常用的Aware接口

Aware接口是一种框架辅助属性注入的一种思想，其他框架中也可以看到类似的接口。框架具备高度封装性，我们接触到的一般都是业务代码，一个底层功能API不能轻易的获取到，但是这不意味着永远用不到这些对象，如果用到了，就可以使用框架提供的类似Aware的接口，让框架给我们注入该对象。

接口	回调方法	作用
ServletContextAware	setServletContext(ServletContext context)	Spring框架回调方法注入ServletContext对象 web环境下才生效
BeanFactoryAware	setBeanFactory(BeanFactory factory)	Spring框架回调方法注入beanFactory对象
BeanNameAware	setBeanName(String beanName)	Spring框架回调方法注入当前Bean在容器中的beanName
ApplicationContextAware	setApplicationContext(ApplicationContext applicationContext)	Spring框架回调方法注入applicationContext

xml整合第三方框架

有两种整合方案：
1.不需要自定义名空间，不需要使用Spring的配置文件配置第三方框架本身内容，例如：MyBatis;
2.需要引入第三方框架命名空间，需要使用Sorina的配置文件配置第三方框架本身内容，例如：Dubbo。

Spring整合MyBatis的步骤如下：
1.导入MyBatis整合Spring的相关坐标；
mybatis-spring和spring-jdbc
2.编写Mapper和Mapper.xml;
3.配置SqlSessionFactoryBean和MapperScannerConfigurer
4.编写测试代码

<!--配置数据源信息-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>                 <property name="url" value="jdbc:mysql://localhost:3306/mybatis"></property> 
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
</bean>
<!--配置SqlSessionFactoryBean，将SqlSessionFactory存储到spring容器-->
<bean class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
</bean>
<!--MapperScannerConfiqurer，扫描指定的包，产生Mapper对象存储到Spring容器-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
       <property name="basePackage"  value="com.ting.mapper"></property>
 </bean>

在mybatis-config.xml

<mappers>
    <package  name="com.ting.mapper"></package>
<mappers>

public class UserServiceImpl implements UserService{
    //需要Mapper
    private UserMapper userMapper;
    pubiic void setUserMapper(UserMapper userMapper){
    this.userMapper = userMapper;
    }
    
     @override
     public void show(){
         List<User> all= userMapper.findAll();
          for (User user :all) {
              System.out.println(user);
            }
        }
}

<bean id="userService"  class="com.ting.service.impl.UserServiceImpl">
    <property  name="userMapper" ref="userMapper"></property>
</bean>

public interface UserMapper{
   List<User>findAll();
}

UserMapper.xml

<?xml version="1.0"encoding="UTF-8"?>

<!DOCTYPE mapper

      PUBLIC"-//mybatis.org//DTD Mapper 3.0//EN"

"https://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.ting.mapper.UserMapper">

<select id="findAl1" resultType="com.ting.pojo.User">

select* from tb user

</ select>

</mapper>