MeiMing_104

Spring笔记(一)(黑马)(Ioc基础容器)

01、传统Javaweb开发的困惑

1.1 传统Javaweb开发困惑及解决方案

问题一：层与层之间紧密耦合在了一起，接口与具体实现紧密耦合在了一起
解决思路：程序代码中不要手动new对象，第三方根据要求为程序提供需要的Bean对象。

问题二：通用的事务功能耦合在业务代码中，通用的日志功能耦合在业务代码中
解决思路：程序代码中不要手动new对象，第三方根据要求为程序提供需要的Bean对象的代理对象。

02、IoC、DI和AOP思想提出

2.1 三种思想的提出

IoC思想：

Inversion of Control，控制反转，强调的是原来在程序中创建Bean的权利反转给第三方。

DI思想：

Dependency Injection，依赖注入，强调的Bean之间的关系，这种由第三方负责去设置。

AOP思想：

Aspect Oriented Peogramming，面向切面编程，功能的横向抽取，主要的实现方式就是Proxy

2.2 框架概念的出现

框架的基本特点：

框架(Framework)，是基于基础技术之上，从众多业务中抽取出的通用解决方案；
框架是一个半成品，使用框架规定的语法可以提高开发效率，可以用简单地代码就能完成复杂的基础业务；
框架内部使用大量的设计模式、算法、底层代码操作技术，如反射、内省、xml解析、注解解析等；
框架一般都具备扩展性；
有了框架，我们可以将精力尽可能的投入在纯业务开发上而不用去费心技术实现以及一些辅助业务。

Java中常用的框架：
不同语言，不同领域都有属于自己的框架，使用框架开发是作为程序员的最基础的底线。Java语言中的框架，可以分为基础框架和服务框架：

基础框架：完成基本业务操作的框架，如MyBatis、Spring、SpringMVC、Struts2、Hibernate等
服务框架：特定领域的框架，一般还可以对外提供服务框架，如MQ、ES、Nacos等

03、Spring框架的诞生

3.1 Spring框架概述

Spring 框架概述

Spring是一个开源的轻量级Java开发应用框架，可以简化企业级应用开发。Spring解决了开发者在JavaEE开发中遇到的许多常见的问题，提供了功能强大IOC、AOP及Web MVC等功能。是当前企业中Java开发几乎不能缺少的框架之一。Spring的生态及其完善，不管是Spring哪个领域的解决方案都是依附于在Spring Framework基础框架的

Spring 框架概述

Spring的官网：www.spring.io

3.2 Spring框架的历史

Spring 框架的历史
- Jsp 默默扛下所有；
- MVC+三层架构分工明确，但开发成本及其高；
- EJB 重量级框架出现，走出一个困境，有进入另一个困境；
- Spring 春天来到，随之，SSH风生水起、称霸武林；
- Spring 稳住江湖大哥位置，SSM开始上位；
- Spring 本着“拿来主义”的思维快速发展，生态不断健全；
- SpringBoot 又一里程碑崛起，把“约定大于配置“思想玩儿的炉火纯青；
- SpringCloud 打包了微服务众多解决方案，应对互联网项目更加easy！

3.3 Spring Framework技术栈图示

3.4 BeanFactory快速入门

根据下图，分析一下Spring的BeanFactory的开发步骤：
1）导入Spring的jar包或Maven坐标；


<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-contextartifactId>
    <version>5.3.7version>
dependency>

内部jar包：

2）定义UserService接口及其UserServiceImpl实现类；

public interface UserService {}
public class UserServiceImpl implements UserService{}

3）创建beans.xml配置文件，将UserServiceImpl的信息配置到该xml中；


<bean id="userService" class="com.mem.service.impl.UserServiceImpl">bean>

4）编写测试代码，创建BeanFactory，加载配置文件，获取UserService实例对象。

public class BeanFactoryTest {
    public static void main(String[] args) {
        //创建BeanFactory
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        //创建读取器
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
        //加载配置文件
        reader.loadBeanDefinitions("beans.xml");
        //获取Bean实例对象
        UserService userService = (UserService) beanFactory.getBean("userService");
        System.out.println(userService); 
    }
}
// com.mem.service.impl.UserServiceImpl@357246de

上面使用BeanFactory完成了IoC思想的实现，下面去实现以下DI依赖注入：

1）定义UserDao接口及其UserDaoImpl实现类；

public interface UserDao {}
public class UserDaoImpl implements UserDao {}

2）修改UserServiceImpl代码，添加一个setUserDao(UserDao userDao)用于接收注入的对象；

public class UserServiceImpl implements UserService {
    private UserDao userDao;
    // BeanFactory去调用该方法，从容器中获得userDao设置到此处
    public void setUserDao(UserDao userDao){
        System.out.println("setUserDao() 执行了");
        this.userDao = userDao;
    }
}

3）修改beans.xml配置文件，在UserDaoImpl的中嵌入配置注入；

<bean id="userService" class="com.mem.service.impl.UserServiceImpl">
    
    
    <property name="userDao" ref="userDao">property>
bean>

<bean id="userDao" class="com.mem.dao.impl.UserDaoImpl">bean>

4）修改测试代码，获得UserService时，setUserService方法执行了注入操作。

public class Test01_BeanFactory {
    public static void main(String[] args) {
        //创建BeanFactory
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        //创建读取器
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
        //加载配置文件
        reader.loadBeanDefinitions("beans.xml");
        //获取Bean实例对象
        UserService userService = (UserService) beanFactory.getBean("userService");
        System.out.println(userService);
    }
}
// 输出结果
// setUserDao() 执行了
// com.mem.service.impl.UserServiceImpl@783e6358

3.5 ApplicationContext快速入门

ApplicationContext 称为Spring容器，内部封装了BeanFactory，比BeanFactory功能更丰富更强大，使用 ApplicationContext 进行开发时，xml配置文件的名称习惯写成applicationContext.xml

public class Test02_ApplicationContext {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService) applicationContext.getBean("userService");
        System.out.println(userService);
        /**
         * setUserDao() 执行了
         * com.mem.service.impl.UserServiceImpl@4e9ba398
         */
    }
}

3.6 BeanFactory与ApplicationContext的关系

BeanFactory与ApplicationContext的关系

BeanFactory是Spring的早期接口，称为Spring的Bean工厂，ApplicationContext是后期更高级接口，称之为Spring容器
ApplicationContext在BeanFactory基础上对功能进行了扩展，例如：监听功能、国际化功能等。BeanFactory的API更偏向底层，ApplicationContext的API大多数是对这些底层API的封装；

ApplicationContext除了继承了BeanFactory外，还继承了ApplicationEventPublisher（事件发布器）、 ResouresPatternResolver（资源解析器）、MessageSource（消息资源）等。但是ApplicationContext的核心功能还是BeanFactory。

Bean创建的主要逻辑和功能都被封装在BeanFactory中，ApplicationContext不仅继承了BeanFactory，而且ApplicationContext内部还维护着BeanFactory的引用，所以ApplicationContext与BeanFactory既有继承关系，又有组合关系。

applicationContext内部维护着beanFactory的引用，在学习过程中会查看beanFactory内部维护的属性，断点查看如下图示内容的

Bean的初始化时机不同，原始BeanFactory是在首次调用getBean时才进行Bean的创建，而ApplicationContext则是配置文件加载，容器一创建就将Bean都实例化并初始化好。

验证BeanFactory和ApplicationContext对Bean的初始化时机，在UserDaoImpl的无参构造内打印一句话，验证构造方法的执行时机

断点观察，
BeanFactory方式时，当调用getBean方法时才会把需要的Bean实例创建，即延迟加载；而 ApplicationContext是加载配置文件，容器创建时就将所有的Bean实例都创建好了，存储到一个单例池中，当调用getBean时直接从单例池中获取Bean实例返回

3.7 BeanFactory的继承体系

BeanFactory是核心接口，项目运行过程中肯定有具体实现参与，这个具体实现就是DefaultListableBeanFactory ，而ApplicationContext内部维护的Beanfactory的实现类也是它

3.8 ApplicationContext的继承体系

只在Spring基础环境下，即只导入spring-context坐标时，此时ApplicationContext的继承体系

只在Spring基础环境下，常用的三个ApplicationContext作用如下：

实现类	功能描述
ClassPathXmlApplicationContext	加载类路径下的xml配置的ApplicationContext
FileSystemXmlApplicationContext	加载磁盘路径下的xml配置的ApplicationContext
AnnotationConfigApplicationContext	加载注解配置类的ApplicationContext

如果Spring基础环境中加入了其他组件解决方案，如web层解决方案，即导入spring-web坐标，此时 ApplicationContext的继承体系

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-webartifactId>
    <version>5.3.7version>
dependency>

新增了两个ApplicationContext

在Spring的web环境下，常用的两个ApplicationContext作用如下：

实现类	功能描述
XmlWebApplicationContext	web环境下，加载类路径下的xml配置的ApplicationContext
AnnotationConfigWebApplicationContext	web环境下，加载磁盘路径下的xml配置的ApplicationContext

PS：web环境下的这两个ApplicationContext，在学习Spring集成web时在进行讲解

04、基于xml的Spring应用

4.1 Spring Bean的配置详解

Spring开发中主要是对Bean的配置，Bean的常用配置一览如下：

Xml配置方式	功能描述
	Bean的id和全限定名配置
	通过name设置Bean的别名，通过别名也能直接获取到Bean实例
	Bean的作用范围，BeanFactory作为容器时取值singleton和prototype
	Bean的实例化时机，是否延迟加载。BeanFactory作为容器时无效
	Bean实例化后自动执行的初始化方法，method指定方法名
	Bean实例销毁前的方法，method指定方法名
	设置自动注入模式，常用的有按照类型byType，按照名字byName
	指定哪个工厂Bean的哪个方法完成Bean的创建

1）Bean的基础配置

例如：配置UserDaoImpl由Spring容器负责管理

<bean id="userDao" class="com.mem.dao.impl.UserDaoImpl"/>

此时存储到Spring容器(beanFactory中的singleObjects单例池)(ConcurrentHashMap)中的Bean的beanName是userDao，值是UserDaoImpl对象，可以根据beanName获取Bean实例

applicationContext.getBean("userDao");

如果不配置id，则Spring会把当前Bean实例的全限定名作为beanName ，如下图所示

applicationContext.getBean("com.mem.dao.impl.UserDaoImpl");

2）Bean的别名配置

可以为当前Bean指定多个别名，根据别名也可以获得Bean对象

<bean id="userDao" name="aaa,bbb" class="com.mem.dao.impl.UserDaoImpl"/>

此时多个名称都可以获得UserDaoImpl实例对象，singleObjects中还是仍然是userDao，别名存储在beanFactory的aliasMap中

applicationContext.getBean("userDao");
applicationContext.getBean("aaa");
applicationContext.getBean("bbb");

如果不配置id，则Spring会把当前name属性的第一个别名(aaa)作为beanName，如下图所示

3）Bean的范围配置

默认情况下，单纯的Spring环境Bean的作用范围有两个：Singleton和Prototype

singleton：单例，默认值，Spring容器创建的时候，就会进行Bean的实例化，并存储到容器内部的单例池中，每次getBean时都是从单例池中获取相同的Bean实例；
prototype：原型，Spring容器初始化时不会创建Bean实例，当调用getBean时才会实例化Bean，每次 getBean都会创建一个新的Bean实例。

当scope设置为singleton时，获得两次对象打印结果是一样的

<bean scope="singleton" id="userDao" class="com.mem.dao.impl.UserDaoImpl">bean>

public class Test03_XmlBeanAttribute03 {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext2.xml");
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
        UserDao userDao2 = (UserDao) applicationContext.getBean("userDao");
        System.out.println(userDao); // com.mem.dao.impl.UserDaoImpl@1ed4004b
        System.out.println(userDao2); // com.mem.dao.impl.UserDaoImpl@1ed4004b
    }
}

通过断点调试，观察可以发现单例池中存在 userDao 实例

当scope设置为prototype时，获得两次对象打印结果是不一样的

<bean scope="prototype" id="userDao" class="com.mem.dao.impl.UserDaoImpl"/>

public class Test03_XmlBeanAttribute03 {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext2.xml");
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
        UserDao userDao2 = (UserDao) applicationContext.getBean("userDao");
        System.out.println(userDao); // com.mem.dao.impl.UserDaoImpl@564fabc8
        System.out.println(userDao2); // com.mem.dao.impl.UserDaoImpl@16d04d3d
    }
}

通过断点调试，观察可以发现单例池中不存在 userDao 实例，但是 userDao的信息已经被存储到 beanFactory.beanDefinitionMap中了

4）Bean的延迟加载

当lazy-init设置为true时为延迟加载，也就是当Spring容器创建的时候，不会立即创建Bean实例，等待用到时在创建Bean实例并存储到单例池中去，后续在使用该Bean直接从单例池获取即可，本质上该Bean还是单例的

<bean lazy-init="true" id="userDao" class="com.mem.dao.impl.UserDaoImpl"/>

5）Bean的初始化和销毁方法配置

Bean在被实例化后，可以执行指定的初始化方法完成一些初始化的操作，Bean在销毁之前也可以执行指定的销毁方法完成一些操作，初始化方法名称和销毁方法名称通过

<bean init-method="init" destroy-method="destroy" id="userDao" class="com.mem.dao.impl.UserDaoImpl"/>

public class UserDaoImpl implements UserDao {
    public UserDaoImpl(){
        System.out.println("userDaoImpl 创建了");
    }
    public void init(){
        System.out.println("初始化方法。。。");
    }
    public void destroy(){
        System.out.println("销毁方法。。。");
    }
}

public class Test03_XmlBeanAttribute05 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext2.xml");
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
        System.out.println(userDao);
        applicationContext.close(); // 调用close时，才有机会执行销毁方法
        /**
         * userDaoImpl 创建了
         * 初始化方法。。。
         * com.mem.dao.impl.UserDaoImpl@5702b3b1
         * 销毁方法。。。
         */
    }
}

扩展：除此之外，我们还可以通过实现 InitializingBean 接口，完成一些Bean的初始化操作，如下：

public class UserDaoImpl implements UserDao, InitializingBean {
    public UserDaoImpl(){
        System.out.println("userDaoImpl 创建了");
    }
    public void init(){
        System.out.println("初始化方法。。。");
    }
    public void destroy(){
        System.out.println("销毁方法。。。");
    }
    // 执行时机早于init() 方法
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean。。。");
    }
}

public class Test03_XmlBeanAttribute05 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext2.xml");
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
        System.out.println(userDao);
        applicationContext.close(); // 调用close时，才有机会执行销毁方法
        /**
         * userDaoImpl 创建了
         * InitializingBean。。。
         * 初始化方法。。。
         * com.mem.dao.impl.UserDaoImpl@69ea3742
         * 销毁方法。。。
         */
    }
}

6）Bean的实例化配置

Spring的实例化方式主要如下两种：

构造方式实例化：底层通过构造方法对Bean进行实例化
工厂方式实例化：底层通过调用自定义的工厂方法对Bean进行实例化

构造方式实例化：

构造方式实例化Bean又分为无参构造方法实例化和有参构造方法实例化，Spring中配置的几乎都是无参构造该方式。

同时配置了有参构造和无参构造，默认找的是无参构造，若注释了无参构造，会报错。

<bean id="userDao" class="com.mem.dao.impl.UserDaoImpl">bean>

public class UserDaoImpl implements UserDao {
    public UserDaoImpl(){
        System.out.println("UserDaoImpl() 执行了");
    }
    public UserDaoImpl(String name){
        System.out.println("UserDaoImpl(String name) 执行了,name="+name);
    }
}

public class Test03_XmlBeanAttribute06 {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext2.xml");
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
        System.out.println(userDao);
    }
}
// 无参没有注释时
UserDaoImpl() 执行了
com.mem.dao.impl.UserDaoImpl@1ed4004b
// 无参被注释时
Failed to instantiate [com.mem.dao.impl.UserDaoImpl]: No default constructor found;

所以需要显示的设置有参构造方法，下面讲解有参构造方法实例化Bean
为xml文件添加constructor-arg标签

<bean id="userDao" class="com.mem.dao.impl.UserDaoImpl">
    <constructor-arg name="name" value="mem"/>
bean>

运行结果

public class Test03_XmlBeanAttribute06 {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext2.xml");
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
        System.out.println(userDao);
    }
}
// 运行结果
UserDaoImpl(String name) 执行了,name=mem
com.mem.dao.impl.UserDaoImpl@369f73a2

工厂方式实例化

工厂方式实例化Bean，又分为如下三种：

静态工厂方法实例化Bean
实例工厂方法实例化Bean
实现FactoryBean规范延迟实例化Bean

①静态工厂方法

静态工厂方法实例化Bean，其实就是定义一个工厂类，提供一个静态方法用于生产Bean实例，在将该工厂类及其静态方法配置给Spring即可


<bean id="userDao" class="com.mem.factory.UserDaoFactoryBean" factory-method="getUserDaoByStatic">
    <constructor-arg name="name" value="mem">constructor-arg>
bean>

PS：标签不仅仅是为构造方法传递参数，只要是为了实例化对象而传递的参数都可以通过标签完成，例如上面通过静态工厂方法实例化Bean所传递的参数也是要通过进行传递的

public class UserDaoFactoryBean {
    // 无参静态工厂方法
    public static UserDao getUserDaoByStatic(){
        // 自定义处理逻辑
        return new UserDaoImpl();
    }
    // 有参静态工厂方法
    public static UserDao getUserDaoByStatic(String name){
        // 自定义处理逻辑
        System.out.println("静态工厂方法, name:" + name);
        return new UserDaoImpl(name);
    }
}

测试代码，直接通过ApplicationContext获得userDao即可

public class Test03_XmlBeanAttribute06 {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext2.xml");
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
        System.out.println(userDao);
    }
}
// 测试有参
静态工厂方法, name:mem
UserDaoImpl(String name) 执行了,name=mem
com.mem.dao.impl.UserDaoImpl@1d16f93d

断点调试：
发现单例池中没有UserDaoFactoryBean对象，有userDao对象

使用静态工厂方法的优点：

在bean创建前后，可以添加自定义的逻辑代码

如果想要引用第三方的工具类，并交给Spring管理时，可以使用这种方式

②实例工厂方法

实例工厂方法，也就是非静态工厂方法产生Bean实例，与静态工厂方式比较，该方式需要先有工厂对象，在用工厂对象去调用非静态方法，所以在进行配置时，要先配置工厂Bean，在配置目标Bean


<bean id="userDao" factory-bean="userDaoFactoryBean" factory-method="getUserDao">
    <constructor-arg name="name" value="mem">constructor-arg>
bean>

<bean id="userDaoFactoryBean" class="com.mem.factory.UserDaoFactoryBean">bean>

public class UserDaoFactoryBean {

    // 无参非静态工厂方法
    public UserDao getUserDao(){
        // 自定义处理逻辑
        return new UserDaoImpl();
    }
    // 有参非静态工厂方法
    public UserDao getUserDao(String name){
        // 自定义处理逻辑
        System.out.println("非静态工厂方法, name:" + name);
        return new UserDaoImpl(name);
    }
}
// 测试有参
非静态工厂方法, name:mem
UserDaoImpl(String name) 执行了,name=mem
com.mem.dao.impl.UserDaoImpl@65e2dbf3

public class Test03_XmlBeanAttribute06 {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext2.xml");
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
        System.out.println(userDao);
    }
}

断点调试：
发现单例池中不仅有userDao对象，而且还有UserDaoFactoryBean对象

使用实例工厂方法的优点：

在bean创建前后，可以添加自定义的逻辑代码

如果想要引用第三方的工具类，并交给Spring管理时，可以使用这种方式

③实现FactoryBean

上面不管是静态工厂方式还是非静态工厂方式，都是自定义的工厂方法，Spring提供了FactoryBean的接口规范， FactoryBean接口定义如下：

public interface FactoryBean<T> {
    String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";

    @Nullable
    T getObject() throws Exception;

    @Nullable
    Class<?> getObjectType();

    default boolean isSingleton() {
        return true;
    }
}

PS： @Nullable 注解 TODO

首先：定义工厂实现FactoryBean

public class UserDaoFactoryBean2 implements FactoryBean<UserDao> {

    @Override
    public UserDao getObject() throws Exception {
        return new UserDaoImpl();
    }

    @Override
    public Class<?> getObjectType() {
        return UserDao.class;
    }
}

其次：配置FactoryBean交由Spring管理即可


<bean id="userDao2" class="com.mem.factory.UserDaoFactoryBean2">bean>

最后：通过Spring容器根据beanName可以正常获得UserDaoImpl

public class Test03_XmlBeanAttribute06 {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext2.xml");
        UserDao userDao = (UserDao) applicationContext.getBean("userDao2");
        System.out.println(userDao);
    }
}
// 打印结果
UserDaoImpl() 执行了
com.mem.dao.impl.UserDaoImpl@4bec1f0c

断点调试：发现单例池中的对象并不是UserDaoImpl了，而是UserDaoFactoryBean2

用第三种方式实现，具有延迟功能；
通过断点观察发现Spring容器创建时，FactoryBean被实例化了，并存储到了单例池singletonObjects中，但是 getObject()方法尚未被执行，UserDaoImpl也没被实例化，当首次用到UserDaoImpl时，才调用getObject()，此工厂方式产生的Bean实例不会存储到单例池singletonObjects中，会存储到 factoryBeanObjectCache 缓存池中，并且后期每次使用到userDao都从该缓存池中返回的是同一个userDao实例

第一次调用时，写入缓存，第二次调用时，直接去缓存中查找。
好处：可以临时把需要产生某些bean的需求存起来，等什么时候用到，再产生。

7）Bean的依赖注入配置

Bean的依赖注入有两种方式：

其中，ref 是 reference 的缩写形式，翻译为：涉及，参考的意思，用于引用其他Bean的id。value 用于注入普通属性值

依赖注入的数据类型有如下三种：

普通数据类型，例如：String、int、boolean等，通过value属性指定。
引用数据类型，例如：UserDaoImpl、DataSource等，通过ref属性指定。
集合数据类型，例如：List、Map、Properties等

普通数据类型、引用数据类型略

集合数据类型如下所示

①List：

注入 List 集合 – 普通数据

注入 List 集合 – 引用数据

注入 List 集合 – 引用数据也可以直接引用容器中存在的Bean

也可以直接引用容器中存在的Bean

②注入 Set 集合

③注入 Map 集合

④注入 Properties 键值对

扩展：自动装配方式
如果被注入的属性类型是Bean引用的话，那么可以在标签中使用 autowire 属性去配置自动注入方式，属性值有两个：

byName：通过属性名自动装配，即去匹配 setXxx 与 id=“xxx”（name=“xxx”）是否一致
byType：通过Bean的类型从容器中匹配，匹配出多个相同Bean类型时，报错。

通过类型装配，如果有多个userDao的bean，则会报错：No qualifying bean of type ‘com.mem.dao.UserDao’ available: expected single matching bean but found 2: userDao,userDao2

8）Spring的其他配置标签

Spring 的 xml 标签大体上分为两类，一种是默认标签，一种是自定义标签

默认标签：就是不用额外导入其他命名空间约束的标签，例如标签
自定义标签：就是需要额外引入其他命名空间约束，并通过前缀引用的标签，例如 context:property-placeholder/ 标签

默认标签

Spring的默认标签用到的是Spring的默认命名空间


<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
beans>

该命名空间约束下的默认标签如下：

标签，除了经常用的做为根标签外，还可以嵌套在根标签内，使用profile属性切换开发环境

可以使用以下两种方式指定被激活的环境：

使用命令行动态参数，虚拟机参数位置加载 -Dspring.profiles.active=test
使用代码的方式设置环境变量 System.setProperty("spring.profiles.active","test")

标签，用于导入其他配置文件，项目变大后，就会导致一个配置文件内容过多，可以将一个配置文件根据业务某块进行拆分，拆分后，最终通过标签导入到一个主配置文件中，项目加载主配置文件就连同导入的文件一并加载了

标签是为某个Bean添加别名，与在标签上使用name属性添加别名的方式一样，我们为 UserServiceImpl指定四个别名：aaa、bbb、xxx、yyy

断点调试，在beanFactory中维护着一个名为aliasMap的Map集合，存储别名和beanName 之间的映射关系

自定义标签

Spring的自定义标签需要引入外部的命名空间，并为外部的命名空间指定前缀，使用 <前缀:标签> 形式的标签，称之为自定义标签，自定义标签的解析流程也是 Spring xml扩展点方式之一，在《Spring整合其他框架》章节进行详细介绍

4.2 Spring的get方法

//根据beanName获取容器中的Bean实例，需要手动强转
UserService userService = (UserService) applicationContext.getBean("userService");
//根据Bean类型去容器中匹配对应的Bean实例，如存在多个匹配Bean则报错
UserService userService2 = applicationContext.getBean(UserService.class);
//根据beanName获取容器中的Bean实例，指定Bean的Type类型
UserService userService3 = applicationContext.getBean("userService", UserService.class);

4.3 Spring配置非自定义Bean

以上在 xml 中配置的Bean都是自己定义的，例如：UserDaoImpl，UserServiceImpl。但是，在实际开发中有些功能类并不是我们自己定义的，而是使用的第三方jar包中的，那么，这些Bean要想让Spring进行管理，也需要对其进行配置

配置非自定义的Bean需要考虑如下两个问题：

被配置的Bean的实例化方式是什么？无参构造、有参构造、静态工厂方式还是实例工厂方式；
被配置的Bean是否需要注入必要属性。

1）配置 Druid 数据源交由Spring管理

导入Druid坐标


<dependency>
    <groupId>com.alibabagroupId>
    <artifactId>druidartifactId>
    <version>1.1.17version>
dependency>

<dependency>
    <groupId>mysqlgroupId>
    <artifactId>mysql-connector-javaartifactId>
    <version>5.1.49version>
dependency>

配置 DruidDataSource
原来的方式

现在的方式


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

2）配置Connection交由Spring管理 (静态工厂方法案例)

Connection 的产生是通过DriverManager的静态方法getConnection获取的，所以我们要用静态工厂方式配置
原来的方式

现在的方式


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

3）配置日期对象交由Spring管理 (非静态工厂方法案例)

原来的方式

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

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

4）配置MyBatis的SqlSessionFactory交由Spring管理

导入MyBatis的相关坐标：

<dependency>
    <groupId>mysqlgroupId>
    <artifactId>mysql-connector-javaartifactId>
    <version>5.1.49version>
dependency>
<dependency>
    <groupId>org.mybatisgroupId>
    <artifactId>mybatisartifactId>
    <version>3.5.7version>
dependency>

原来的方式

现在的方式


<bean id="in" class="org.apache.ibatis.io.Resources" factory-method="getResourceAsFile">
    <constructor-arg name="resource" value="mybatis-config.xml">constructor-arg>
bean>

<bean id="builder" class="org.apache.ibatis.session.SqlSessionFactoryBuilder">bean>

<bean id="sqlSessionFactory" factory-bean="builder" factory-method="build">
    <constructor-arg name="inputStream" ref="in">constructor-arg>
bean>

4.4 Bean实例化的基本流程

Spring容器在进行初始化时，会将xml配置的的信息封装成一个BeanDefinition对象，所有的 BeanDefinition存储到一个名为beanDefinitionMap的Map集合中去，Spring框架在对该Map进行遍历，使用反射创建Bean实例对象，创建好的Bean对象存储在一个名为singletonObjects的Map集合中，当调用getBean方法时则最终从该Map集合中取出Bean实例对象返回

DefaultListableBeanFactory对象内部维护着一个Map用于存储封装好的BeanDefinitionMap

Spring框架会取出beanDefinitionMap中的每个BeanDefinition信息，反射构造方法或调用指定的工厂方法生成Bean实例对象，所以只要将BeanDefinition注册到beanDefinitionMap这个Map中，Spring就会进行对应的Bean的实例化操作

singletonObjects这个map在DefaultSingletonBeanRegistry类中声明

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap(256);
}

总结
基本步骤：

加载xml配置文件，解析获取配置中的每个的信息，封装成一个个的BeanDefinition对象;
将BeanDefinition存储在一个名为beanDefinitionMap的Map中;
ApplicationContext底层遍历beanDefinitionMap，创建Bean实例对象;
创建好的Bean实例对象，被存储到一个名为singletonObjects的Map中;
当执行applicationContext.getBean(beanName)时，从singletonObjects去匹配Bean实例返回

4.5 Spring的后处理器

Spring的后处理器是Spring对外开发的重要扩展点，允许我们介入到Bean的整个实例化流程中来，以达到动态注册 BeanDefinition，动态修改BeanDefinition，以及动态修改Bean的作用。
Spring主要有两种后处理器：

BeanFactoryPostProcessor：Bean工厂后处理器，在BeanDefinitionMap填充完毕，Bean实例化之前执行；（执行一次）
BeanPostProcessor：Bean后处理器，一般在Bean实例化之后，填充到单例池singletonObjects之前执行。（执行大于一次）

1) Bean工厂后处理器 – BeanFactoryPostProcessor - 针对BeanDefinition

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

@FunctionalInterface
public interface BeanFactoryPostProcessor {
    void postProcessBeanFactory(ConfigurableListableBeanFactory var1) throws BeansException;
}

修改BeanDefinition
编写BeanFactoryPostProcessor

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("MyBeanFactoryPostProcessor的postProcessBeanFactory方法执行了");
        // 修改xml中的bean 
        BeanDefinition userServiceBD = beanFactory.getBeanDefinition("userService"); //获得UserDao定义对象
        userServiceBD.setBeanClassName("com.mem.dao.impl.UserDaoImpl");  //修改class
        //userServiceBD.setInitMethodName(methodName); //修改初始化方法
        //userServiceBD.setLazyInit(true); //修改是否懒加载
        //... 省略其他的设置方式 ...
    }
}

配置BeanFactoryPostProcessor

<bean id="userService" class="com.mem.service.impl.UserServiceImpl2">bean>
<bean id="userDao" class="com.mem.dao.impl.UserDaoImpl">bean>
<bean class="com.mem.processor.MyBeanFactoryPostProcessor"/>

测试：发现原来的xml中userService 被修改成了UserDaoImpl对象

public class Test06_BeanFactoryPostProcessor01 {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext6.xml");
        Object userService =  applicationContext.getBean("userService");
        System.out.println(userService);
    }
}
// 结果
MyBeanFactoryPostProcessor的postProcessBeanFactory方法执行了
com.mem.dao.impl.UserDaoImpl@192b07fd

注册新的BeanDefinition
在MyBeanFactoryPostProcessor类中添加相关的代码

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("MyBeanFactoryPostProcessor的postProcessBeanFactory方法执行了");
        // 注册一个新的UserServiceImpl2对象
        // 强转成子类DefaultListableBeanFactory
        if (beanFactory instanceof DefaultListableBeanFactory){
            DefaultListableBeanFactory beanFactory1 = (DefaultListableBeanFactory) beanFactory;
            BeanDefinition beanDefinition = new RootBeanDefinition();
            beanDefinition.setBeanClassName("com.mem.service.impl.UserServiceImpl2");
            // 进行注册操作
            beanFactory1.registerBeanDefinition("userService2",beanDefinition);
        }
    }
}

测试：userService2作为beanName，去查找。

public class Test05_PostProcessor {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext6.xml");
        Object userService2 =  applicationContext.getBean("userService2");
        System.out.println(userService2);
    }
}
// 结果
MyBeanFactoryPostProcessor的postProcessBeanFactory方法执行了
com.mem.service.impl.UserServiceImpl2@192b07fd

**简化：**Spring 提供了一个BeanFactoryPostProcessor的子接口BeanDefinitionRegistryPostProcessor专门用于注册 BeanDefinition操作如下所示:

public class MyBeanFactoryPostProcessor2 implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
        System.out.println("MyBeanFactoryPostProcessor2的postProcessBeanDefinitionRegistry方法执行了");
        BeanDefinition beanDefinition = new RootBeanDefinition();
        beanDefinition.setBeanClassName("com.mem.service.impl.UserServiceImpl2");
        beanDefinitionRegistry.registerBeanDefinition("userService2",beanDefinition);
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("MyBeanFactoryPostProcessor2的postProcessBeanFactory方法执行了");
    }
}

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("MyBeanFactoryPostProcessor的postProcessBeanFactory方法执行了");
    }
}

测试：优先级顺序

public class Test06_BeanFactoryPostProcessor01 {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext6.xml");
        Object userService2 =  applicationContext.getBean("userService2");
        System.out.println(userService2);
    }
}
// 结果
MyBeanFactoryPostProcessor2的postProcessBeanDefinitionRegistry方法执行了
MyBeanFactoryPostProcessor2的postProcessBeanFactory方法执行了
MyBeanFactoryPostProcessor的postProcessBeanFactory方法执行了
com.mem.service.impl.UserServiceImpl2@55d56113

如上结果所示：MyBeanFactoryPostProcessor2类中的postProcessBeanDefinitionRegistry先执行，其次是postProcessBeanFactory，最后才是MyBeanFactoryPostProcessor类中的postProcessBeanFactory方法。
流程图完善：

案例，使用Spring的BeanFactoryPostProcessor扩展点完成自定义注解扫描

要求如下：

自定义@MyComponent注解，使用在类上；
使用资料中提供好的包扫描器工具BaseClassScanUtils 完成指定包的类扫描；
自定义BeanFactoryPostProcessor完成注解@MyComponent的解析，解析后最终被Spring管理。

实现：
自定义@MyComponent注解，使用在类上

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyComponent {
    // 显示的指定的beanName
    String value() default "";
}

在类上使用@MyComponent

@MyComponent("firstBean")
public class FirstBeanByAnno {
}

自定义BeanFactoryPostProcessor完成注解解析

public class MyBeanFactoryPostProcessor3 implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
        System.out.println("MyBeanFactoryPostProcessor3的postProcessBeanDefinitionRegistry方法执行了");
        //指定要扫描的包
        String basePackage = "com.mem";
        //调用扫描工具扫描指定包及其子包下的@MyComponent
        Map<String, Class> scanMyComponentAnnotation = BaseClassScanUtils.scanMyComponentAnnotation(basePackage);
        //遍历Map集合，创建BeanDefinition对象进行注册
        scanMyComponentAnnotation.forEach((beanName,clazz)->{
            BeanDefinition beanDefinition = new RootBeanDefinition();
            beanDefinition.setBeanClassName(clazz.getName());
            beanDefinitionRegistry.registerBeanDefinition(beanName,beanDefinition);
        });
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("MyBeanFactoryPostProcessor3的postProcessBeanFactory方法执行了");
    }
}

配置自定义BeanFactoryPostProcessor到xml中

<bean class="com.mem.processor.MyBeanFactoryPostProcessor3"/>

测试类

public class Test06_BeanFactoryPostProcessor02 {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext6.xml");
        Object firstBean =  applicationContext.getBean("firstBean");
        System.out.println(firstBean);
    }
}

包扫描工具类

public class BaseClassScanUtils {

    //设置资源规则
    private static final String RESOURCE_PATTERN = "/**/*.class";

    public static Map<String, Class> scanMyComponentAnnotation(String basePackage) {

        //创建容器存储使用了指定注解的Bean字节码对象
        Map<String, Class> annotationClassMap = new HashMap<String, Class>();

        //spring工具类，可以获取指定路径下的全部类
        ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
        try {
            String pattern = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
            ClassUtils.convertClassNameToResourcePath(basePackage) + RESOURCE_PATTERN;
            Resource[] resources = resourcePatternResolver.getResources(pattern);
            //MetadataReader 的工厂类
            MetadataReaderFactory refractory = new CachingMetadataReaderFactory(resourcePatternResolver);
            for (Resource resource : resources) {
                //用于读取类信息
                MetadataReader reader = refractory.getMetadataReader(resource);
                //扫描到的class
                String classname = reader.getClassMetadata().getClassName();
                Class<?> clazz = Class.forName(classname);
                //判断是否属于指定的注解类型
                if(clazz.isAnnotationPresent(MyComponent.class)){
                    //获得注解对象
                    MyComponent annotation = clazz.getAnnotation(MyComponent.class);
                    //获得属value属性值
                    String beanName = annotation.value();
                    //判断是否为""
                    if(beanName!=null&&!beanName.equals("")){
                        //存储到Map中去
                        annotationClassMap.put(beanName,clazz);
                        continue;
                    }

                    //如果没有为"",那就把当前类的类名作为beanName
                    annotationClassMap.put(clazz.getSimpleName(),clazz);

                }
            }
        } catch (Exception exception) {
        }

        return annotationClassMap;
    }

    public static void main(String[] args) {
        Map<String, Class> stringClassMap = scanMyComponentAnnotation("com.mem");
        System.out.println(stringClassMap);
    }
}

2) Bean后处理器 – BeanPostProcessor - 针对Bean

Bean被实例化后，到最终缓存到名为singletonObjects单例池之前，中间会经过Bean的初始化过程，例如：属性的填充、初始方法init的执行等，其中有一个对外进行扩展的点BeanPostProcessor，我们称为Bean后处理。跟上面的 Bean工厂后处理器相似，它也是一个接口，实现了该接口并被容器管理的BeanPostProcessor，会在流程节点上被 Spring自动调用。

BeanPostProcessor的接口定义如下：

public interface BeanPostProcessor {
    @Nullable
    //在属性注入完毕，init初始化方法执行之前被回调
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Nullable
    //在初始化方法执行之后，被添加到单例池singletonObjects之前被回调
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

自定义MyBeanPostProcessor，完成快速入门测试

public class MyBeanPostProcessor implements BeanPostProcessor {
    // 初始化之前执行
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println(beanName+"-BeanPostProcessor的before方法...");
        return bean;
    }
    // 初始化之后执行
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println(beanName+"-BeanPostProcessor的after方法...");
        return bean;
    }
}

public class UserDaoImpl implements UserDao, InitializingBean {
    public UserDaoImpl(){
        System.out.println("UserDaoImpl创建了...");
    }
    public UserDaoImpl(String name){
        //        System.out.println("UserDaoImpl(String name) 执行了,name="+name);
    }
    public void init(){
        System.out.println("UserDaoImpl初始化方法执行...");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("UserDaoImpl属性填充...");
    }
}

配置MyBeanPostProcessor

<bean id="userDao" class="com.mem.dao.impl.UserDaoImpl" init-method="init">bean>
<bean class="com.mem.processor.MyBeanPostProcessor"/>

测试类：

public class Test07_BeanPostProcessor01 {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext7.xml");
        Object userDao =  applicationContext.getBean("userDao");
        System.out.println(userDao);
    }
}
// 结果
UserDaoImpl创建了...
userDao-BeanPostProcessor的before方法...
UserDaoImpl属性填充...
UserDaoImpl初始化方法执行...
userDao-BeanPostProcessor的after方法...
com.mem.dao.impl.UserDaoImpl@6adbc9d

案例，对Bean方法进行执行时间日志增强

要求如下：

Bean的方法执行之前控制台打印当前时间；
Bean的方法执行之后控制台打印当前时间。

分析：

对方法进行增强主要就是代理设计模式和包装设计模式；
由于Bean方法不确定，所以使用动态代理在运行期间执行增强操作；
在Bean实例创建完毕后，进入到单例池之前，使用Proxy代替真是的目标Bean

实现：
编写BeanPostProcessor，增强逻辑编写在 after方法中

public class MyBeanPostProcessor2 implements BeanPostProcessor {
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // 使用动态代理对目标bean进行增强，返回proxy对象，进而存储到单例池中
        Object proxyInstance = Proxy.newProxyInstance(
            bean.getClass().getClassLoader(),
            bean.getClass().getInterfaces(),
            (proxy,method,args)->{
                // 1. 输出开始时间
                System.out.println("方法："+method.getName()+"-开始时间："+new Date());
                // 2. 执行目标方法
                Object result = method.invoke(bean, args);
                // 3. 输出结束时间
                System.out.println("方法："+method.getName()+"-结束时间："+new Date());
                return result;
            }
        );
        return proxyInstance;
    }
}

public class UserDaoImpl implements UserDao {
    public UserDaoImpl(){
        //        System.out.println("UserDaoImpl创建了...");
    }

    @Override
    public void show() {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("show()....");
    }
}

配置BeanPostProcessor

<bean id="userDao" class="com.mem.dao.impl.UserDaoImpl">bean>
<bean class="com.mem.processor.MyBeanPostProcessor2"/>

测试类：

public class Test07_BeanPostProcessor02 {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext7.xml");
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
        userDao.show();
    }
}
// 结果
方法：show-开始时间：Sat Jun 24 18:11:07 CST 2023
show()....
方法：show-结束时间：Sat Jun 24 18:11:10 CST 2023

流程图完善：

4.6 Spring Bean的生命周期

Spring Bean的生命周期是从 Bean 实例化之后，即通过反射创建出对象之后，到Bean成为一个完整对象，最终存储到单例池中，这个过程被称为Spring Bean的生命周期。
Spring Bean的生命周期大体上分为三个阶段：

Bean的实例化阶段：Spring框架会取出BeanDefinition的信息进行判断当前Bean的范围是否是singleton的，是否不是延迟加载的，是否不是FactoryBean等，最终将一个普通的singleton的Bean通过反射进行实例化；
Bean的初始化阶段：Bean创建之后还仅仅是个"半成品"，还需要对Bean实例的属性进行填充、执行一些Aware 接口方法、执行BeanPostProcessor方法、执行InitializingBean接口的初始化方法、执行自定义初始化init方法等。该阶段是Spring最具技术含量和复杂度的阶段，Aop增强功能，后面要学习的Spring的注解功能等、 spring高频面试题Bean的循环引用问题都是在这个阶段体现的；
Bean的完成阶段：经过初始化阶段，Bean就成为了一个完整的Spring Bean，被存储到单例池 singletonObjects中去了，即完成了Spring Bean的整个生命周期。

由于Bean的初始化阶段的步骤比较复杂，所以着重研究Bean的初始化阶段

初始化阶段

Spring Bean的初始化过程涉及如下几个过程：

Bean实例的属性填充
Aware接口属性注入
BeanPostProcessor的before()方法回调
InitializingBean接口的初始化方法回调
自定义初始化方法init回调
BeanPostProcessor的after()方法回调

PS：通过代码验证上述初始化顺序… …

Bean实例属性填充

BeanDefinition中有对当前Bean实体的注入信息通过属性propertyValues进行了存储，例如UserService的属性信息如下:

Spring在进行属性注入时，会分为如下几种情况：

注入普通属性，String、int或存储基本类型的集合时，直接通过set方法的反射设置进去；
注入单向对象引用属性时，从容器中getBean获取后通过set方法反射设置进去，如果容器中没有，则先创建被注入对象Bean实例（完成整个生命周期）后，在进行注入操作；
注入双向对象引用属性时，就比较复杂了，涉及了循环引用（循环依赖）问题，下面会详细阐述解决方案。

PS：通过代码验证上述第二第三种属性填充… …

①略
②针对单向对象引用属性时，执行的顺序问题：

public class UserServiceImpl implements UserService {
    public UserServiceImpl() {
        System.out.println("UserServiceImpl创建了...");
    }

    private UserDao userDao;
    public void setUserDao(UserDao userDao){
        System.out.println("setUserDao()执行了，注入成功...");
        this.userDao = userDao;
    }
}

public class UserDaoImpl implements UserDao {
    public UserDaoImpl(){
        System.out.println("UserDaoImpl创建了...");
    }
}

配置xml文件：


<bean id="userService" class="com.mem.service.impl.UserServiceImpl">
  
  <property name="userDao" ref="userDao">property>
bean>

<bean id="userDao" class="com.mem.dao.impl.UserDaoImpl">bean>

测试顺序：

public class Test04_AttributeInput {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService) applicationContext.getBean("userService");
        System.out.println(userService);
    }
}
//情况1(调整xml中userDao的位置，位于userService后面)：
UserServiceImpl创建了...
UserDaoImpl创建了...
setUserDao()执行了，注入成功...
//情况2(调整xml中userDao的位置，位于userService前面)：
UserDaoImpl创建了...
UserServiceImpl创建了...
setUserDao()执行了，注入成功...

③针对双向对象引用属性时，产生的循环引用问题：
多个实体之间相互依赖并形成闭环的情况就叫做"循环依赖"，也叫做"循环引用"
问题描述：

如下图所示：

调用getBean(“userService”)时，实例化userService，并在内存开辟空间 X001 用于存储；
userService初始化(属性填充userDao对象)；
去单例池中查找userDao，发现没有；
实例化userDao对象，并在内存开辟空间 X002 用于存储；
userDao初始化(属性填充userService对象)；
去单例池中查找userService，发现没有；
再次循环

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

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

@FunctionalInterface
public interface ObjectFactory<T> {
    T getObject() throws BeansException;
}

结合之前的图讲解，

UserService创建完毕之后，把UserService的引用存储到第三级缓存中（存储的并不是Bean本身，而是ObjectFactory，等用到的时候，在调用getObject()方法，进行真正创建）

UserService 属性注入，需要UserDao，从缓存中获取，没有UserDao；

UserDao实例化对象，但尚未初始化，将UserDao存储到到三级缓存；

UserDao属性注入，需要UserService，从三级缓存获取UserService，UserService从三级缓存移入二级缓存；

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

UserService 注入UserDao；

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

二级缓存和三级缓存的区别：

二级缓存存的是被引用的Bean
三级缓存存的是未被引用的Bean

代码验证后，分析出UserService与UserDao实例化与初始化的顺序如下：

三级缓存源码剖析流程.pdf

常用的Aware接口

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

public class UserServiceImpl implements UserService, ServletContextAware,
ApplicationContextAware, BeanFactoryAware, BeanNameAware {
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void setServletContext(ServletContext servletContext) {
        System.out.println(servletContext);
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println(applicationContext);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println(beanFactory);
    }

    @Override
    public void setBeanName(String s) {
        System.out.println(s);
    }
}

<bean id="userDao" class="com.mem.dao.impl.UserDaoImpl">bean>
<bean id="userService" class="com.mem.service.impl.UserServiceImpl">
  <property name="userDao" ref="userDao">property>
bean>

测试类：

public class Test09_Aware {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext9.xml");
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
        UserService userService = (UserService) applicationContext.getBean("userService");
    }
}
// 结果
// beanName
Service 
// BeanFactory
org.springframework.beans.factory.support.DefaultListableBeanFactory@6fb554cc: defining beans [userDao,userService]; root of factory hierarchy
// ApplicationContext
org.springframework.context.support.ClassPathXmlApplicationContext@65b3120a, started on Sun Jun 25 22:31:27 CST 2023

4.7 Spring IoC整体流程总结

总流程图:

简易版：

详解：

bean标签首先通过Reader读取，封装成BeanDefinition对象；

把每个bean标签都封装成BeanDefinition对象，存入beanDefinitionMap中；

Spring循环beanDefinitionMap，取出每个beanDefinition对象，通过反射创建真正的实例对象；

将所有创建的对象存入singletonObjects单例池Map中；

当我们调用getBean方法，其实就是从单例池中获取对象。

扩展1：加入bean工厂后处理器(BeanFactoryPostProcessor)

详解：

将BD存入beanDefinitionMap中后，经过Bean工厂后处理器及其子类可以动态的添加一些BD到beanDefinitionMap

由于BeanFactoryPostProcessor的注册bean功能实现较为复杂，添加其子类BeanDefinitionRegistryPostProcessor来处理注册bean功能

扩展2：加入BeanPostProcessor

详解：

在Obj初始化对象之前，执行before()方法，在Obj初始化之后执行after()方法

可以利用这两方法对Obj做增强，修改属性，添加属性，动态代理之类的

汇总版：

4.8 Spring xml方式整合第三方框架

xml整合第三方框架有两种整合方案：

不需要自定义名空间，不需要使用Spring的配置文件配置第三方框架本身内容，例如：MyBatis；
需要引入第三方框架命名空间，需要使用Spring的配置文件配置第三方框架本身内容，例如：Dubbo。

不需要自定义名空间

Spring整合MyBatis

之前已经在Spring中简单的配置了SqlSessionFactory，但是这不是正规的整合方式， MyBatis提供了mybatis-spring.jar专门用于两大框架的整合。

原来的MyBatis的步骤如下：

编写配置文件mybatis-config.xml
编写Mapper接口及Mapper配置xml
编写测试代码

编写配置文件mybatis-config.xml


DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            dataSource>
        environment>
    environments>
    <mappers>
        <package name="com.mem.mapper"/>
    mappers>
configuration>

编写Mapper接口及Mapper配置xml

package com.mem.mapper;
import com.mem.pojo.User;
import java.util.List;

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

public class User {
    private Integer id;
    private String username;
    private String password;
}


DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mem.mapper.UserMapper">
    <select id="findAll" resultType="com.mem.pojo.User">
        select * from user
    select>
mapper>

编写测试代码

public class MybatisTest {
    public static void main(String[] args) throws Exception {
        InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactoryBuilder factoryBuilder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = factoryBuilder.build(in);
        SqlSession session = sqlSessionFactory.openSession();
        UserMapper userMapper = session.getMapper(UserMapper.class);
        List<User> all = userMapper.findAll();
        all.forEach(System.out::println);
    }
}
// 结果
User{id=1, username='张三', password='123456'}
User{id=2, username='李四', password='654321'}

Spring整合MyBatis的步骤如下：

导入MyBatis整合Spring的相关坐标；（请见资料中的pom.xml）
编写Mapper和Mapper.xml；
配置SqlSessionFactoryBean和MapperScannerConfigurer；
编写测试代码

导入MyBatis整合Spring的相关坐标

<dependency>
    <groupId>mysqlgroupId>
    <artifactId>mysql-connector-javaartifactId>
    <version>5.1.49version>
dependency>
<dependency>
    <groupId>org.mybatisgroupId>
    <artifactId>mybatisartifactId>
    <version>3.5.7version>
dependency>
<dependency>
    <groupId>org.mybatisgroupId>
    <artifactId>mybatis-springartifactId>
    <version>2.0.6version>
dependency>
<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-jdbcartifactId>
    <version>5.3.12version>
dependency>

配置SqlSessionFactoryBean和MapperScannerConfigurer：



<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver">property>
    <property name="url" value="jdbc:mysql://192.168.91.135:3306/mybatis?useSSL=false">property>
    <property name="username" value="root">property>
    <property name="password" value="123456">property>
bean>


<bean class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
bean>


<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.mem.mapper"/>
bean>

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

编写Mapper和Mapper.xml

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


DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mem.mapper.UserMapper">
    <select id="findAll" resultType="com.mem.pojo.User">
        select * from user
    select>
mapper>

编写测试代码

public class Test10_Mybatis {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext10.xml");
        UserService userService = (UserService) applicationContext.getBean("userService");
        userService.show();
    }
}
// 结果
User{id=1, username='张三', password='123456'}
User{id=2, username='李四', password='654321'}

Spring整合MyBatis的原理剖析

整合包里提供了一个SqlSessionFactoryBean和一个扫描Mapper的配置对象，SqlSessionFactoryBean一旦被实例化，就开始扫描Mapper并通过动态代理产生Mapper的实现类存储到Spring容器中。相关的有如下四个类：

SqlSessionFactoryBean：需要进行配置，用于提供SqlSessionFactory；
MapperScannerConfigurer：需要进行配置，用于扫描指定mapper注册BeanDefinition；
MapperFactoryBean：Mapper的FactoryBean，获得指定Mapper时调用getObject方法；
ClassPathMapperScanner：definition.setAutowireMode(2) 修改了自动注入状态，所以 MapperFactoryBean中的setSqlSessionFactory会自动注入进去。

SqlSessionFactoryBean
配置SqlSessionFactoryBean作用是向容器中提供SqlSessionFactory，SqlSessionFactoryBean实现了 FactoryBean和InitializingBean两个接口，所以会自动执行getObject() 和afterPropertiesSet()方法

public class SqlSessionFactoryBean implements FactoryBean<SqlSessionFactory>, InitializingBean, ApplicationListener<ApplicationEvent> {
	// FactoryBean中重写的方法，用于延迟返回 sqlSessionFactory
    public SqlSessionFactory getObject() throws Exception {
        if (this.sqlSessionFactory == null) {
            this.afterPropertiesSet();
        }
        return this.sqlSessionFactory;
    }
    // InitializingBean中重写的方法，用于创建 sqlSessionFactory
    public void afterPropertiesSet() throws Exception {
        // ~~~
        this.sqlSessionFactory = this.buildSqlSessionFactory();
    }
    protected SqlSessionFactory buildSqlSessionFactory() throws Exception {
        // 相当于原来mybatis中的SqlSessionFactory sqlSessionFactory = factoryBuilder.build(in)
    	return this.sqlSessionFactoryBuilder.build(targetConfiguration);
    }
}

MapperScannerConfigurer
配置MapperScannerConfigurer作用是扫描Mapper，向容器中注册Mapper对应的MapperFactoryBean， MapperScannerConfigurer实现了BeanDefinitionRegistryPostProcessor和InitializingBean两个接口，会在 postProcessBeanDefinitionRegistry方法中向容器中注册MapperFactoryBean

public class MapperScannerConfigurer implements BeanDefinitionRegistryPostProcessor, InitializingBean, ApplicationContextAware, BeanNameAware {
	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    	// 类加载路径下的扫描器
        ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
        // 1. 调用父类(ClassPathBeanDefinitionScanner)中的scan方法
        scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage, ",; \t\n"));
    }
}

public class ClassPathBeanDefinitionScanner extends ClassPathScanningCandidateComponentProvider {
	public int scan(String... basePackages) {
        int beanCountAtScanStart = this.registry.getBeanDefinitionCount();
        // 2. 调用的是子类(ClassPathMapperScanner)中的doScan方法
        this.doScan(basePackages);
    }
    protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
        // 4. 注册BeanDefinition到BeanDefinitionMap中，
        // definitionHolder中封装着BeanDefinition, 此时这个BD的beanClass: UserMapper(接口) 
        this.registerBeanDefinition(definitionHolder, this.registry);
        return beanDefinitions;
    }
}

public class ClassPathMapperScanner extends ClassPathBeanDefinitionScanner {
	public Set<BeanDefinitionHolder> doScan(String... basePackages) {
        // 3. 调用父类(ClassPathBeanDefinitionScanner)中的doScan方法，返回beanDefinitions集合
        Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);
        // 5. 调用自身的processBeanDefinitions方法
        this.processBeanDefinitions(beanDefinitions);
        return beanDefinitions;
    }
    // 用于修改definition的beanClass
    private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
        BeanDefinitionHolder holder = (BeanDefinitionHolder)var4.next();
        AbstractBeanDefinition definition = (AbstractBeanDefinition)holder.getBeanDefinition();
        // 6. UserMapper -> MapperFactoryBean 不然没法创建对象
        definition.setBeanClass(this.mapperFactoryBeanClass);
        // 8. 按照类型去注入MapperFactoryBean的getObject()方法所需的sqlSessionFactory对象
        definition.setAutowireMode(2); // PS：autowireMode取值：1是根据名称自动装配，2是根据类型自动装配  
    }
}

public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> {
	// 7. 当调用getBean()方法时，底层调用getObject()，用于动态返回bean
    public T getObject() throws Exception {
        // 相当于原来的
        // SqlSession session = sqlSessionFactory.openSession();
        // UserMapper userMapper = session.getMapper(UserMapper.class);
        return this.getSqlSession().getMapper(this.mapperInterface);
    }
}

总结：

SqlSessionFactoryBean，负责产生SqlSessionFactory，并把SqlSessionFactory扔到Spring容器中，谁用谁按类型或名称注入；
MapperScannerConfigurer，作为扫描的入口，用于加载配置文件，扫描包；
在扫描时，内部调用ClassPathMapperScanner的scan方法进行相应的扫描；
把扫描好的BeanDefinition扔到BDMap中；
再通过ClassPathMapperScanner去修改BeaClass的路径，改为MapperFactoryBean的全路径；
当调用getBean(UserMapper.class)时，通过MapperFactoryBean中的getObject()方法，去获取Mapper对象；

需要引入第三方框架命名空间

Spring 整合其他组件时就不像MyBatis这么简单了，例如Dubbo框架在于Spring进行整合时，要使用Dubbo提供的命名空间的扩展方式，自定义了一些Dubbo的标签

为了降低我们此处的学习成本，不在引入Dubbo第三方框架了，以Spring的 context 命名空间去进行讲解，该方式也是命名空间扩展方式。

context命名空间

需求：加载外部properties文件，将键值对存储在Spring容器中

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?useSSL=false
jdbc.username=root
jdbc.password=123456

引入context命名空间，在使用context命名空间的标签，使用SpEL表达式在xml或注解中根据key获得value


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

    
    
    <context:property-placeholder location="jdbc.properties"/>

    
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}">property>
        <property name="url" value="${jdbc.url}">property>
        <property name="username" value="${jdbc.username}">property>
        <property name="password" value="${jdbc.password}">property>
    bean>

    
    <bean class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
    bean>

    
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.mem.mapper"/>
    bean>
beans>

其实，加载的properties文件中的属性最终通过Spring解析后会被存储到了Spring容器的environment中去，不仅自己定义的属性会进行存储，Spring也会把环境相关的一些属性进行存储

原理剖析解析过程：

只能从源头ClassPathXmlApplicationContext入手，经历复杂的源码追踪，找到如下两个点：
1）在创建DefaultNamespaceHandlerResolver时，为处理器映射地址handlerMappingsLocation属性赋值，并加载命名空间处理器到Map handlerMappings 中去

第一点完成后，Map集合handlerMappings就被填充了很多XxxNamespaceHandler，继续往下追代码
2）在DefaultBeanDefinitionDocumentReader的parseBeanDefinitions方法中，发现如下逻辑：

如果是默认命名空间，则执行parseDefaultElement方法

如果是自定义命名空间，则执行parseCustomElement方法

在执行resovle方法时，就是从这个名为handlerMappings的Map中根据命名空间名称获得对应的处理器对象，此处是ContextNamespaceHandler，最终执行NamespaceHandler的parse方法

ContextNamespaceHandler源码如下，间接实现了NamespaceHandler接口，初始化方法init会被自动调用。由于 context命名空间下有多个标签，所以每个标签又单独注册了对应的解析器，注册到了其父类 NamespaceHandlerSupport的Map parsers中去了

通过上述分析，我们清楚的了解了外部命名空间标签的执行流程，如下：

将自定义标签的约束与物理约束文件与网络约束名称的约束以键值对形式存储到一个spring.schemas文件里，该文件存储在类加载路径的 META-INF里，Spring会自动加载到;
将自定义命名空间的名称与自定义命名空间的处理器映射关系以键值对形式存在到一个叫spring.handlers文件里，该文件存储在类加载路径的 META-INF里，Spring会自动加载到;
准备好NamespaceHandler，如果命名空间只有一个标签，那么直接在parse方法中进行解析即可，一般解析结果就是注册该标签对应的BeanDefinition。如果命名空间里有多个标签，那么可以在init方法中为每个标签都注册一个BeanDefinitionParser，在执行NamespaceHandler的parse方法时在分流给不同的 BeanDefinitionParser进行解析(重写doParse方法即可)。

案例：自定义命名空间和标签

设想自己是一名架构师，进行某一个框架与Spring的集成开发，效果是通过一个指示标签，向Spring容器中自动注入一个BeanPostProcessor

步骤分析：

确定命名空间名称、schema虚拟路径、标签名称；
编写schema约束文件haohao-annotation.xsd
在类加载路径下创建META目录，编写约束映射文件spring.schemas和处理器映射文件spring.handlers
编写命名空间处理器 HaohaoNamespaceHandler，在init方法中注册HaohaoBeanDefinitionParser
编写标签的解析器 HaohaoBeanDefinitionParser，在parse方法中注册HaohaoBeanPostProcessor
编写HaohaoBeanPostProcessor
以上六步是框架开发者写的，以下是框架使用者写的
在applicationContext.xml配置文件中引入命名空间
在applicationContext.xml配置文件中使用自定义的标签

编写schema约束文件haohao-annotation.xsd

在类加载路径下创建META目录，编写约束映射文件spring.schemas和处理器映射文件spring.handlers

编写命名空间处理器 HaohaoNamespaceHandler，在init方法中注册HaohaoBeanDefinitionParser

编写标签的解析器 HaohaoBeanDefinitionParser，在parse方法中注册HaohaoBeanPostProcessor

编写HaohaoBeanPostProcessor

05、基于注解的Spring应用

5.1 Bean基本注解开发

Spring除了xml配置文件进行配置之外，还可以使用注解方式进行配置，注解方式慢慢成为xml配置的替代方案。我们有了xml开发的经验，学习注解开发就方便了许多，注解开发更加快捷方便。
Spring提供的注解有三个版本：

2.0时代，Spring开始出现注解
2.5时代，Spring的Bean配置可以使用注解完成
3.0时代，Spring其他配置也可以使用注解完成，我们进入全注解时代

基本Bean注解，主要是使用注解的方式替代原有xml的标签及其标签属性的配置

使用@Component 注解替代标签

可以通过@Component注解的value属性指定当前Bean实例的beanName，也可以省略不写，不写的情况下为当前类名首字母小写

使用注解对需要被Spring实例化的Bean进行标注，但是需要告诉Spring去哪找这些Bean，要配置组件扫描路径

使用上述注解完成UserDaoImpl的基本配置

由于JavaEE开发是分层的，为了每层Bean标识的注解语义化更加明确，@Component又衍生出如下三个注解：

5.2 Bean依赖注入注解开发

Bean依赖注入的注解，主要是使用注解的方式替代xml的标签完成属性的注入操作

Spring主要提供如下注解，用于在Bean内部进行属性注入的：

@Value

通过@Value 直接注入普通属性

通过@Value 注入properties文件中的属性

加载properties文件

@Autowired

@Autowired注解，用于根据类型进行注入

当容器中同一类型的Bean实例有多个时，会尝试自动根据名字进行匹配：

当容器中同一类型的Bean实例有多个时，且名字与被注入Bean名称不匹配时会报错

@Qualifier

@Qualifier配合@Autowired可以完成根据名称注入Bean实例，使用@Qualifier指定名称

@Resource

@Resource注解既可以根据类型注入，也可以根据名称注入，无参就是根据类型注入，有参数就是根据名称注入

PS：@Resource注解存在与 javax.annotation 包中，Spring对其进行了解析

/**
 * 扩展@Autowired 按照类型注入，不一定只能在set方法上
 */
@Component
public class UserServiceImpl implements UserService {

    @Autowired
    public void xxx(UserDao userDao){
        System.out.println("xxx："+userDao); 
        // xxx：com.mem.dao.impl.UserDaoImpl@35fc6dc4
    }

    @Autowired
    public void yyy(List<UserDao> userDaoList){
        System.out.println("yyy："+userDaoList); 
        // yyy：[com.mem.dao.impl.UserDaoImpl@35fc6dc4, com.mem.dao.impl.UserDaoImpl2@7fe8ea47]
    }
}

5.3 非自定义Bean注解开发

非自定义Bean不能像自定义Bean一样使用@Component进行管理，非自定义Bean要通过工厂的方式进行实例化，使用@Bean标注方法即可，@Bean的属性为beanName，如不指定为当前工厂方法名称

PS：工厂方法所在类必须要被Spring管理

如果@Bean工厂方法需要参数的话，则有如下几种注入方式：

使用@Autowired 根据类型自动进行Bean的匹配，@Autowired可以省略 ；
使用@Qualifier 根据名称进行Bean的匹配；
使用@Value 根据名称进行普通数据类型匹配。

5.4 Bean配置类的注解开发

@Component等注解替代了标签，但是像、 context:componentScan等非标签怎样去使用注解替代呢？


<context:property-placeholder location="classpath:jdbc.properties"/>

<context:component-scan base-package="com.itheima"/>

<import resource="classpath:beans.xml"/>

定义一个配置类替代原有的xml配置文件，标签以外的标签，一般都是在配置类上使用注解完成的

@Configuration注解标识的类为配置类，替代原有xml配置文件，该注解第一个作用是标识该类是一个配置类，第二个作用是具备@Component作用

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Configuration {
    @AliasFor(
        annotation = Component.class
    )
    String value() default "";

    boolean proxyBeanMethods() default true;
}

@ComponentScan 组件扫描配置，替代原有xml文件中的配置

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
@Repeatable(ComponentScans.class)
public @interface ComponentScan {
    @AliasFor("basePackages")
    String[] value() default {};

    @AliasFor("value")
    String[] basePackages() default {};
    // ~~~~
}

base-package的配置方式：

指定一个或多个包名：扫描指定包及其子包下使用注解的类

不配置包名：扫描当前@componentScan注解配置类所在包及其子包下的类

@PropertySource 注解用于加载外部properties资源配置，替代原有xml中的配置

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Repeatable(PropertySources.class)
public @interface PropertySource {
    String name() default "";

    String[] value();

    boolean ignoreResourceNotFound() default false;

    String encoding() default "";

    Class<? extends PropertySourceFactory> factory() default PropertySourceFactory.class;
}

@Import 用于加载其他配置类，替代原有xml中的配置

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Import {
    Class<?>[] value();
}

使用方法：

@Configuration
// 
@ComponentScan("com.mem")
// 
@PropertySource("classpath:jdbc.properties")
// 
@Import(value = NoCustomBean.class)
public class MyConfig {
}

5.5 Spring配置其他注解

扩展：@Primary注解用于标注相同类型的Bean优先被使用权，@Primary 是Spring3.0引入的，与@Component 和@Bean一起使用，标注该Bean的优先级更高，则在通过类型获取Bean或通过@Autowired根据类型进行注入时，会选用优先级更高的

@Repository("userDao")
public class UserDaoImpl implements UserDao{}

@Repository("userDao2")
@Primary
public class UserDaoImpl2 implements UserDao{}

@Bean
public UserDao userDao01(){return new UserDaoImpl();}

@Bean
@Primary
public UserDao userDao02(){return new UserDaoImpl2();}

扩展：@Profile 注解的作用同于xml配置时学习profile属性，是进行环境切换使用的

<beans profile="test">

注解 @Profile 标注在类或方法上，标注当前产生的Bean从属于哪个环境，只有激活了当前环境，被标注的Bean才能被注册到Spring容器里，不指定环境的Bean，任何环境下都能注册到Spring容器里

@Repository("userDao")
@Profile("test")
public class UserDaoImpl implements UserDao{}

@Repository("userDao2")
public class UserDaoImpl2 implements UserDao{}

可以使用以下两种方式指定被激活的环境：

使用命令行动态参数，虚拟机参数位置加载 -Dspring.profiles.active=test
使用代码的方式设置环境变量 System.setProperty(“spring.profiles.active”,“test”);

5.6 Spring注解的解析原理

使用@Component等注解配置完毕后，要配置组件扫描才能使注解生效

xml配置组件扫描：

<context:component-scan base-package="com.itheima"/>

配置类配置组件扫描:

@Configuration
@ComponentScan("com.itheima")
public class AppConfig {
}

使用xml方式配置组件扫描，而component-scan是一个context命名空间下的自定义标签，所以要找到对应的命名空间处理器NamespaceHandler 和解析器，查看spring-context包下的spring.handlers文件

查看 ContextNamespaceHandler 类

public void init() {
	this.registerBeanDefinitionParser("component-scan", new ComponentScanBeanDefinitionParser());
}

将ComponentScanBeanDefinitionParser进行了注册，对其源码进行跟踪，最终将标注的@Component的类，生成对应的BeanDefiition进行了注册
//todo 时序图

使用配置类配置组件扫描，使用AnnotationConfigApplicationContext容器在进行创建时，内部调用了如下代码，该工具注册了几个Bean后处理器：

AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);

//todo 时序图
对比：

5.7 Spring注解方式整合第三方框架

第三方框架整合，依然使用MyBatis作为整合对象，之前我们已经使用xml方式整合了MyBatis，现在使用注解方式无非就是将xml标签替换为注解，将xml配置文件替换为配置类而已，原有xml方式整合配置如下：

使用@Bean将DataSource和SqlSessionFactoryBean存储到Spring容器中，而MapperScannerConfigurer使用注解@MapperScan进行指明需要扫描的Mapper在哪个包下，使用注解整合MyBatis配置方式如下：

Spring整合MyBatis的原理

注解方式，Spring整合MyBatis的原理，关键在于@MapperScan，@MapperScan不是Spring提供的注解，是 MyBatis为了整合Spring，在整合包org.mybatis.spring.annotation中提供的注解，源码如下：

重点关注一下@Import({MapperScannerRegistrar.class})，当@MapperScan被扫描加载时，会解析@Import注解，从而加载指定的类，此处就是加载了**MapperScannerRegistrar **

MapperScannerRegistrar实现了ImportBeanDefinitionRegistrar接口，Spring会自动调用 registerBeanDefinitions方法，该方法中又注册MapperScannerConfigurer类，而MapperScannerConfigurer类作用是扫描Mapper，向容器中注册Mapper对应的MapperFactoryBean，前面讲过，此处不在赘述了：

//TODO 时序图

Spring与MyBatis注解方式整合有个重要的技术点就是@Import，第三方框架与Spring整合xml方式很多是凭借自定义标签完成的，而第三方框架与Spring整合注解方式很多是靠@Import注解完成的。
@Import可以导入如下三种类：

普通的配置类
实现ImportSelector接口的类
实现ImportBeanDefinitionRegistrar接口的类

实现ImportSelector接口的类

@Import导入实现了ImportSelector接口的类

ImportSelector接口selectImports方法的参数AnnotationMetadata代表注解的媒体数据，可以获得当前注解修饰的类的元信息，例如：获得组件扫描的包名

//TODO 时序图

实现ImportBeanDefinitionRegistrar接口的类

@Import导入实现ImportBeanDefinitionRegistrar接口的类，实现了该接口的类的registerBeanDefinitions方法会被自动调用，在该方法内可以注册BeanDefinition

//TODO 时序图

你可能感兴趣的:(Spring,spring,笔记,java)

10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
《投行人生》读书笔记小蘑菇的树洞
《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数广龙宇一起学Rust #Rust设计模式 rust 设计模式开发语言
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
git常用命令笔记咩酱-小羊 git 笔记
###用习惯了idea总是不记得git的一些常见命令，需要用到的时候总是担心旁边站了人~~~记个笔记@_@，告诉自己看笔记不丢人初始化初始化一个新的Git仓库gitinit配置配置用户信息gitconfig--globaluser.name"YourName"gitconfig--globaluser.email"[email protected]"基本操作克隆远程仓库gitclone查看
509. 斐波那契数(每日一题) lzyprime
lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
拥有断舍离的心态，过精简生活--《断舍离》读书笔记爱吃丸子的小樱桃
不知不觉间房间里的东西越来越多，虽然摆放整齐，但也时常会觉得空间逼仄，令人心生烦闷。抱着断舍离的态度，我开始阅读《断舍离》这本书，希望从书中能找到一些有效的方法，帮助我实现空间、物品上的断舍离。《断舍离》是日本作家山下英子通过自己的经历、思考和实践总结而成的，整体内涵也从刚开始的私人生活哲学的“断舍离”升华成了“人生实践哲学”，接着又成为每个人都能实行的“改变人生的断舍离”，从“哲学”逐渐升华成“
四章-32-点要素的聚合彩云飘过
本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java 算法华为 javascript
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
高端密码学院笔记285 柚子_b4b4
高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
Day17笔记-高阶函数 ~在杰难逃~ Python 笔记 python 开发语言 pycharm 数据分析
高阶函数【重点掌握】函数的本质：函数是一个变量，函数名是一个变量名，一个函数可以作为另一个函数的参数或返回值使用如果A函数作为B函数的参数，B函数调用完成之后，会得到一个结果，则B函数被称为高阶函数常用的高阶函数：map(),reduce(),filter(),sorted()1.map()map(func,iterable)，返回值是一个iterator【容器，迭代器】func:函数iterab
Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Python python 开发语言大数据数据分析数据挖掘
大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
数据仓库——维度表一致性墨染丶eye 背诵数据仓库
数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
【Git】常见命令(仅笔记) 好想有猫猫 Git Linux学习笔记 git 笔记 elasticsearch linux c++
文章目录创建/初始化本地仓库添加本地仓库配置项提交文件查看仓库状态回退仓库查看日志分支删除文件暂存工作区代码远程仓库使用`.gitigore`文件让git不追踪一些文件标签创建/初始化本地仓库gitinit添加本地仓库配置项gitconfig-l#以列表形式显示配置项gitconfiguser.name"ljh"#配置user.namegitconfiguser.email"[email protected]
SpringBlade dict-biz/list 接口 SQL 注入漏洞文章永久免费只为良心 oracle 数据库
SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
Java 重写(Override)与重载(Overload) 叨唧唧的
Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
简单了解 JVM 记得开心一点啊 jvm
目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
为什么你总是对下属不满意? ZhaoWu1050
【ZhaoWu的听课笔记】大多数公司，都存在两种问题。我创业四年，更是体会深切。这两种问题就是：老板经常不满意下属的表现；下属总是不知道老板想要什么；虽然这两种问题普遍存在，其实解决方法并不复杂。这节课，我们再聊聊第一个问题：为什么老板经常不满意下属表现?其实，这背后也是一条管理常识。管理学家德鲁克先生早就说过：管理者的任务，不是去改变人。*来自《卓有成效的管理者》只是大多数老板和我一样，都是一边
母亲节如何做小红书营销美橙传媒
小红书的一举一动引起了外界的高度关注。通过爆款笔记和流行话题，我们可以看到“干货”类型的内容在小红书中偏向实用的生活经验共享和生活指南非常受欢迎。根据运营社的分析，这种现象是由小红书用户心智和内容社区背后机制共同决定的。首先，小红书将使用“强搜索”逻辑为用户提供特定的“搜索场景”。在“我必须这样生活”中，大量使用了满足小红书站用户喜好和需求的内容。内容社区自制的高质量内容也吸引了寻找营销新途径的品
Java企业面试题3 马龙强_ java
1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Java java
Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
读书笔记|《遇见孩子，遇见更好的自己》5 抹茶社长
为人父母意味着放弃自己的过去，不要对以往没有实现的心愿耿耿于怀，只有这样，孩子们才能做回自己。985909803.jpg孩子在与父母保持亲密的同时更需要独立，唯有这样，孩子才会成为孩子，父母才会成其为父母。有耐心的人生往往更幸福，给孩子留点余地。认识到养儿育女是对耐心的考验。为失败做好心理准备，教会孩子控制情绪。了解自己的底线，说到底线，有一点很重要，父母之所以发脾气，真正的原因往往在于他们自己，
Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
java的(PO,VO,TO,BO,DAO,POJO) Cb123456 VO TO BO POJO DAO
转: http://www.cnblogs.com/yxnchinahlj/archive/2012/02/24/2366110.html ------------------------------------------------------------------- O/R Mapping 是 Object Relational Mapping（对象关系映
spring ioc原理（看完后大家可以自己写一个spring） aijuans spring
最近，买了本Spring入门书：spring In Action 。大致浏览了下感觉还不错。就是入门了点。Manning的书还是不错的，我虽然不像哪些只看Manning书的人那样专注于Manning,但怀着崇敬的心情和激情通览了一遍。又一次接受了IOC 、DI、AOP等Spring核心概念。先就IOC和DI谈一点我的看法。IO
MyEclipse 2014中Customize Persperctive设置无效的解决方法 Kai_Ge MyEclipse2014
高高兴兴下载个MyEclipse2014，发现工具条上多了个手机开发的按钮，心生不爽就想弄掉他！结果发现Customize Persperctive失效！！有说更新下就好了，可是国内Myeclipse访问不了，何谈更新... so~这里提供了更新后的一下jar包，给大家使用！ 1、将9个jar复制到myeclipse安装目录\plugins中 2、删除和这9个jar同包名但是版本号较
SpringMvc上传 120153216 springMVC
@RequestMapping(value = WebUrlConstant.UPLOADFILE) @ResponseBody public Map<String, Object> uploadFile(HttpServletRequest request,HttpServletResponse httpresponse) { try { //
Javascript----HTML DOM 事件何必如此 JavaScript html Web
HTML DOM 事件允许Javascript在HTML文档元素中注册不同事件处理程序。事件通常与函数结合使用，函数不会在事件发生前被执行！注：DOM：指明使用的 DOM 属性级别。 1.鼠标事件属性
动态绑定和删除onclick事件 357029540 JavaScript jquery
因为对JQUERY和JS的动态绑定事件的不熟悉，今天花了好久的时间才把动态绑定和删除onclick事件搞定!现在分享下我的过程。在我的查询页面，我将我的onclick事件绑定到了tr标签上同时传入当前行(this值)参数，这样可以在点击行上的任意地方时可以选中checkbox，但是在我的某一列上也有一个onclick事件是用于下载附件的，当
HttpClient|HttpClient请求详解 7454103 apache 应用服务器网络协议网络应用 Security
HttpClient 是 Apache Jakarta Common 下的子项目，可以用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。本文首先介绍 HTTPClient，然后根据作者实际工作经验给出了一些常见问题的解决方法。HTTP 协议可能是现在 Internet 上使用得最多、最重要的协议了，越来越多的 Java 应用程序需
递归逐层统计树形结构数据 darkranger 数据结构
将集合递归获取树形结构: /** * * 递归获取数据 * @param alist:所有分类 * @param subjname:对应统计的项目名称 * @param pk:对应项目主键 * @param reportList: 最后统计的结果集 * @param count:项目级别 */ public void getReportVO(Arr
访问WEB-INF下使用frameset标签页面出错的原因 aijuans struts2
<frameset rows="61,*,24" cols="*" framespacing="0" frameborder="no" border="0">
MAVEN常用命令 avords
Maven库： http://repo2.maven.org/maven2/ Maven依赖查询： http://mvnrepository.com/ Maven常用命令： 1. 创建Maven的普通java项目： mvn archetype:create -DgroupId=packageName
PHP如果自带一个小型的web服务器就好了 houxinyou apache 应用服务器 Web PHP 脚本
最近单位用PHP做网站，感觉PHP挺好的，不过有一些地方不太习惯，比如，环境搭建。PHP本身就是一个网站后台脚本，但用PHP做程序时还要下载apache，配置起来也不太很方便，虽然有好多配置好的apache+php+mysq的环境，但用起来总是心里不太舒服，因为我要的只是一个开发环境，如果是真实的运行环境，下个apahe也无所谓，但只是一个开发环境，总有一种杀鸡用牛刀的感觉。如果php自己的程序中
NoSQL数据库之Redis数据库管理(list类型) bijian1013 redis 数据库 NoSQL
3.list类型及操作 List是一个链表结构，主要功能是push、pop、获取一个范围的所有值等等，操作key理解为链表的名字。Redis的list类型其实就是一个每个子元素都是string类型的双向链表。我们可以通过push、pop操作从链表的头部或者尾部添加删除元素，这样list既可以作为栈，又可以作为队列。 &nbs
谁在用Hadoop？ bingyingao hadoop 数据挖掘公司应用场景
Hadoop技术的应用已经十分广泛了，而我是最近才开始对它有所了解，它在大数据领域的出色表现也让我产生了兴趣。浏览了他的官网，其中有一个页面专门介绍目前世界上有哪些公司在用Hadoop，这些公司涵盖各行各业，不乏一些大公司如alibaba,ebay,amazon,google,facebook,adobe等，主要用于日志分析、数据挖掘、机器学习、构建索引、业务报表等场景,这更加激发了学习它的热情。
【Spark七十六】Spark计算结果存到MySQL bit1129 mysql
package spark.examples.db import java.sql.{PreparedStatement, Connection, DriverManager} import com.mysql.jdbc.Driver import org.apache.spark.{SparkContext, SparkConf} object SparkMySQLInteg
Scala: JVM上的函数编程 bookjovi scala erlang haskell
说Scala是JVM上的函数编程一点也不为过，Scala把面向对象和函数型编程这两种主流编程范式结合了起来，对于熟悉各种编程范式的人而言Scala并没有带来太多革新的编程思想，scala主要的有点在于Java庞大的package优势，这样也就弥补了JVM平台上函数型编程的缺失，MS家.net上已经有了F#，JVM怎么能不跟上呢？对本人而言
jar打成exe bro_feng java jar exe
今天要把jar包打成exe，jsmooth和exe4j都用了。遇见几个问题。记录一下。两个软件都很好使，网上都有图片教程，都挺不错。首先肯定是要用自己的jre的，不然不能通用，其次别忘了把需要的lib放到classPath中。困扰我很久的一个问题是，我自己打包成功后，在一个同事的没有装jdk的电脑上运行，就是不行，报错jvm.dll为无效的windows映像，如截图最后发现
读《研磨设计模式》-代码笔记-策略模式-Strategy bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ /* 策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化简单理解： 1、将不同的策略提炼出一个共同接口。这是容易的，因为不同的策略，只是算法不同，需要传递的参数
cmd命令值cvfM命令 chenyu19891124 cmd
cmd命令还真是强大啊。今天发现jar -cvfM aa.rar @aaalist 就这行命令可以根据aaalist取出相应的文件例如：在d：\workspace\prpall\test.java 有这样一个文件，现在想要将这个文件打成一个包。运行如下命令即可比如在d：\wor
OpenJWeb(1.8) Java Web应用快速开发平台 comsci java 框架 Web 项目管理企业应用
OpenJWeb(1.8) Java Web应用快速开发平台的作者是我们技术联盟的成员，他最近推出了新版本的快速应用开发平台 OpenJWeb(1.8)，我帮他做做宣传 OpenJWeb快速开发平台以快速开发为核心，整合先进的java 开源框架，本着自主开发+应用集成相结合的原则，旨在为政府、企事业单位、软件公司等平台用户提供一个架构透
Python 报错：IndentationError: unexpected indent daizj python tab 空格缩进
IndentationError: unexpected indent 是缩进的问题，也有可能是tab和空格混用啦 Python开发者有意让违反了缩进规则的程序不能通过编译，以此来强制程序员养成良好的编程习惯。并且在Python语言里，缩进而非花括号或者某种关键字，被用于表示语句块的开始和退出。增加缩进表示语句块的开
HttpClient 超时设置 dongwei_6688 httpclient
HttpClient中的超时设置包含两个部分： 1. 建立连接超时，是指在httpclient客户端和服务器端建立连接过程中允许的最大等待时间 2. 读取数据超时，是指在建立连接后，等待读取服务器端的响应数据时允许的最大等待时间在HttpClient 4.x中如下设置： HttpClient httpclient = new DefaultHttpC
小鱼与波浪 dcj3sjt126com
一条小鱼游出水面看蓝天，偶然间遇到了波浪。　　小鱼便与波浪在海面上游戏，随着波浪上下起伏、汹涌前进。　　小鱼在波浪里兴奋得大叫：“你每天都过着这么刺激的生活吗？简直太棒了。”　　波浪说：“岂只每天过这样的生活，几乎每一刻都这么刺激！还有更刺激的，要有潮汐变化，或者狂风暴雨，那才是兴奋得心脏都会跳出来。”　　小鱼说：“真希望我也能变成一个波浪，每天随着风雨、潮汐流动，不知道有多么好！”　　很快，小鱼
Error Code: 1175 You are using safe update mode and you tried to update a table dcj3sjt126com mysql
快速高效用：SET SQL_SAFE_UPDATES = 0；下面的就不要看了！今日用MySQL Workbench进行数据库的管理更新时，执行一个更新的语句碰到以下错误提示： Error Code: 1175 You are using safe update mode and you tried to update a table without a WHERE that
枚举类型详细介绍及方法定义 gaomysion enum javaee
转发 http://developer.51cto.com/art/201107/275031.htm 枚举其实就是一种类型，跟int, char 这种差不多，就是定义变量时限制输入的，你只能够赋enum里面规定的值。建议大家可以看看，这两篇文章，《java枚举类型入门》和《C++的中的结构体和枚举》，供大家参考。枚举类型是JDK5.0的新特征。Sun引进了一个全新的关键字enum
Merge Sorted Array hcx2013 array
Given two sorted integer arrays nums1 and nums2, merge nums2 into nums1 as one sorted array. Note:You may assume that nums1 has enough space (size that is
Expression Language 3.0新特性 jinnianshilongnian el 3.0
Expression Language 3.0表达式语言规范最终版从2013-4-29发布到现在已经非常久的时间了；目前如Tomcat 8、Jetty 9、GlasshFish 4已经支持EL 3.0。新特性包括：如字符串拼接操作符、赋值、分号操作符、对象方法调用、Lambda表达式、静态字段/方法调用、构造器调用、Java8集合操作。目前Glassfish 4/Jetty实现最好，对大多数新特性
超越算法来看待个性化推荐 liyonghui160com 超越算法来看待个性化推荐
一提到个性化推荐，大家一般会想到协同过滤、文本相似等推荐算法，或是更高阶的模型推荐算法，百度的张栋说过，推荐40%取决于UI、30%取决于数据、20%取决于背景知识，虽然本人不是很认同这种比例，但推荐系统中，推荐算法起的作用起的作用是非常有限的。就像任何
写给Javascript初学者的小小建议 pda158 JavaScript
　　一般初学JavaScript的时候最头痛的就是浏览器兼容问题。在Firefox下面好好的代码放到IE就不能显示了，又或者是在IE能正常显示的代码在firefox又报错了。　　如果你正初学JavaScript并有着一样的处境的话建议你：初学JavaScript的时候无视DOM和BOM的兼容性，将更多的时间花在了解语言本身（ECMAScript）。只在特定浏览器编写代码（Chrome/Fi
Java 枚举 ShihLei java enum 枚举
注：文章内容大量借鉴使用网上的资料，可惜没有记录参考地址，只能再传对作者说声抱歉并表示感谢！一基础 1）语法枚举类型只能有私有构造器（这样做可以保证客户代码没有办法新建一个enum的实例）枚举实例必须最先定义 2）特性 &nb
Java SE 6 HotSpot虚拟机的垃圾回收机制 uuhorse java HotSpot GC 垃圾回收 VM
官方资料，关于Java SE 6 HotSpot虚拟机的garbage Collection，非常全，英文。 http://www.oracle.com/technetwork/java/javase/gc-tuning-6-140523.html Java SE 6 HotSpot[tm] Virtual Machine Garbage Collection Tuning &

Spring笔记(一)(黑马)(Ioc基础容器)

01、传统Javaweb开发的困惑

1.1 传统Javaweb开发困惑及解决方案

02、IoC、DI和AOP思想提出

2.1 三种思想的提出

2.2 框架概念的出现

03、Spring框架的诞生

3.1 Spring框架概述

3.2 Spring框架的历史

3.3 Spring Framework技术栈图示

3.4 BeanFactory快速入门

3.5 ApplicationContext快速入门

3.6 BeanFactory与ApplicationContext的关系

3.7 BeanFactory的继承体系

3.8 ApplicationContext的继承体系

04、基于xml的Spring应用

4.1 Spring Bean的配置详解

1）Bean的基础配置

2）Bean的别名配置

3）Bean的范围配置

4）Bean的延迟加载

5）Bean的初始化和销毁方法配置

6）Bean的实例化配置

构造方式实例化：

工厂方式实例化

①静态工厂方法

②实例工厂方法

③实现FactoryBean

7）Bean的依赖注入配置

集合数据类型如下所示

①List：

②注入 Set 集合

③注入 Map 集合

8）Spring的其他配置标签

默认标签

自定义标签

4.2 Spring的get方法

4.3 Spring配置非自定义Bean

1）配置 Druid 数据源交由Spring管理

2）配置Connection交由Spring管理 (静态工厂方法案例)

3）配置日期对象交由Spring管理 (非静态工厂方法案例)

4）配置MyBatis的SqlSessionFactory交由Spring管理

4.4 Bean实例化的基本流程

4.5 Spring的后处理器

1) Bean工厂后处理器 – BeanFactoryPostProcessor - 针对BeanDefinition

案例， 使用Spring的BeanFactoryPostProcessor扩展点完成自定义注解扫描

2) Bean后处理器 – BeanPostProcessor - 针对Bean

案例， 对Bean方法进行执行时间日志增强

4.6 Spring Bean的生命周期

初始化阶段

Bean实例属性填充

三级缓存源码剖析流程.pdf

常用的Aware接口

4.7 Spring IoC整体流程总结

4.8 Spring xml方式整合第三方框架

不需要自定义名空间

Spring整合MyBatis

原来的MyBatis的步骤如下：

Spring整合MyBatis的步骤如下：

Spring整合MyBatis的原理剖析

需要引入第三方框架命名空间

context命名空间

原理剖析解析过程：

案例：自定义命名空间和标签

05、基于注解的Spring应用

5.1 Bean基本注解开发

5.2 Bean依赖注入注解开发

@Value

@Autowired

@Qualifier

@Resource

5.3 非自定义Bean注解开发

5.4 Bean配置类的注解开发

5.5 Spring配置其他注解

5.6 Spring注解的解析原理

5.7 Spring注解方式整合第三方框架

Spring整合MyBatis的原理

实现ImportSelector接口的类

实现ImportBeanDefinitionRegistrar接口的类

你可能感兴趣的:(Spring,spring,笔记,java)

案例，使用Spring的BeanFactoryPostProcessor扩展点完成自定义注解扫描

案例，对Bean方法进行执行时间日志增强