了解Spring、Spring IOC_spring 源码未定义模块jdk-CSDN博客

本文链接：https://blog.csdn.net/JavaJackmake/article/details/106750254

Spring、

Spring简介

Spring框架是一个开源的JavaEE应用程序，两大核心思想就是IOC(控制反转)，DI（依赖注入），AOP（面向切面编程）

Spring IOC

Spring AOP

Spring JDBC+事务

Spring的作用

Dao层

JDBC处理（BaseDao）

对应框架：MyBatis

Service层

Spring框架不是针对Service层业务逻辑，没有合适的框架

Web层（Controller层）

Servlet（接收参数响应数据地址配置页面转发）

对应框架：SpringMVC

Spring框架是基于分布式的应用程序

属于轻量级的框架

配置管理

Bean对象实例化-IOC

集成其他的第三方技术

MyBatis、Hibernate框架（持久层框架）

SpringMVC

Spring Security权限

Quartz时钟框架（定时任务处理）

自带服务

Mail邮件处理

定时任务处理-定时调用（例：定时任务，定时短信）

消息处理（异步处理）

Spring模块划分

Spring IOC模块：Bean对象的实例化 Bean的创建

Spring AOP模块：动态代理面向切面工程

Spring JDBC+事务模块

Spring Web模块

spring环境搭建

1、先创建Maven项目

选择"File"——>选择"New"——>选择Maven

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-G0rb0wx9-1592133690573)(C:\Users\china\AppData\Roaming\Typora\typora-user-images\1591777363897.png)]

2、设置项目的坐标和名字

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kgTehrj1-1592133690576)(C:\Users\china\AppData\Roaming\Typora\typora-user-images\1591777557461.png)]

3、设置项目的Maven环境

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fhTNpgL2-1592133690578)(C:\Users\china\AppData\Roaming\Typora\typora-user-images\1591777945702.png)]

4、设置项目的名称和存放工作空间

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AYzUZSBh-1592133690580)(C:\Users\china\AppData\Roaming\Typora\typora-user-images\1591778070792.png)]

5、修改项目中pom.xml的配置

5.1修改jdk版本

<properties>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <maven.compiler.source>1.8</maven.compiler.source>
  <maven.compiler.target>1.8</maven.compiler.target>
</properties>

5.2修改单元测试的版本

<dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
</dependency>

5.3删除 build标签中的pluginManagement标签

 <build>
    <!--删除 build标签中的pluginManagement标签-->
  </build>

5.4添加sping依赖坐标

Maven仓库：https://mvnrepository.com/

<!--添加 Spring 依赖坐标-->
<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
 <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-context</artifactId>
     <version>4.3.10.RELEASE</version>
 </dependency>

6、添加Spring的配置文件spring.xml

6.1在项目的src下创建文件夹（Alt+insert）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TxwgGnJC-1592133690582)(C:\Users\china\AppData\Roaming\Typora\typora-user-images\1591833799221.png)]

6.2将文件夹标准为资源目录

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HWscRxNy-1592133690584)(C:\Users\china\AppData\Roaming\Typora\typora-user-images\1591833948628.png)]

6.3新建xml文件，将官方文档上的配置拷贝到文件中

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Kfk72QRH-1592133690585)(C:\Users\china\AppData\Roaming\Typora\typora-user-images\1591834167775.png)]

<?xml version="1.0" encoding="UTF-8"?>
<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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="userServices" class="com.shsxt.services.UserServices"></bean>

</beans>

7、创建Bean对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4hvlCmiY-1592133690586)(C:\Users\china\AppData\Roaming\Typora\typora-user-images\1591834513248.png)]

8、通过spring.xml配置Bean对象

 		<bean id="userServices" class="com.shsxt.services.UserServices"></bean>

9、加载配置文件，获取实例化对象

public static void main(String[] args) {
    			  //获取到spring上下环境
     			 ApplicationContext ac=new ClassPathXmlApplicationContext("spring.xml");
     			 //通过get Bean()方法得到Spring实例化的Bean对像
     			 UserServices userServices= (UserServices) ac.getBean("userServices");
     			 userServices.test();

 			 }

对象实例化模拟实现

1、通过构造器得到相关的配置文件
2、通过dom4j解析xml文件，得到List 存放id和class
3、通过反射实例化得到对象 class.forName(类的全路径).newInstance(); 通过Map（id,class)来存储
4、得到指定实例化的对象

实现步骤：

1、创建接口 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uL5ueTCT-1592133690587)(C:\Users\china\AppData\Roaming\Typora\typora-user-images\1591867286034.png)]

2、向pom.xml添加Dom4j坐标依赖

		 <!--添加dom4j的坐标依赖-->
    		<dependency>
     		 	<groupId>dom4j</groupId>
      			<artifactId>dom4j</artifactId>
      			<version>1.6.1</version>
    		</dependency>
    		<dependency>
     			 <groupId>jaxen</groupId>
      			<artifactId>jaxen</artifactId>
      			<version>1.1.6</version>
    		</dependency>

3、编写实现代码

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t9dImVlP-1592133690588)(C:\Users\china\AppData\Roaming\Typora\typora-user-images\1591867329070.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eUwH8ncw-1592133690589)(C:\Users\china\AppData\Roaming\Typora\typora-user-images\1591867353152.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-c7ojeuTH-1592133690590)(C:\Users\china\AppData\Roaming\Typora\typora-user-images\1591867369517.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gD0i1F1j-1592133690591)(C:\Users\china\AppData\Roaming\Typora\typora-user-images\1591867379194.png)]

4、测试

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wNJTCbgA-1592133690592)(C:\Users\china\AppData\Roaming\Typora\typora-user-images\1591867426284.png)]

Spring IOC核心技术

工厂设计模式（简单工厂工厂方法抽象方法）

XML解析（Dom4j Xpath）

反射（实例化对象反射获取方法反射获取属性反射获取构造器）

策略模式（加载资源）

单例（IOC创建的实例化对象都是单例）

Spring IOC配置文件的加载方式

根据相对路径加载资源文件

ApplicationContext ac=new ClassPathXmlApplicationContext("spring.xml");

根据绝对路径加载资源文件(了解)

ApplicationContext ac=new FileSystemXmlApplicationContext("D:\\java\\idea_work\\spring02\\src\\main\\resources\\spring.xml");

同时加载多个资源文件

可变参数，传入多个文件名

//同时加载多个资源文件
ApplicationContext ac=new ClassPathXmlApplicationContext("spring.xml","dao.xml");

通过总的配置文件import配置其他文件

total.xml文件

<?xml version="1.0" encoding="UTF-8" ?>
<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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--导入需要包含的资源文件-->
    <import resource="dao.xml"></import>
    <import resource="spring.xml"></import>
</beans>

spring.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="userServices" class="com.shsxt.services.UserServices">
        <!-- collaborators and configuration for this bean go here -->
    </bean>


</beans>

dao.xml文件

<?xml version="1.0" encoding="UTF-8" ?>
<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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="userDao" class="com.shsxt.dao.UserDao"></bean>
</beans>

2、加载总的资源文件

//加载总的资源文件
ApplicationContext ac=new ClassPathXmlApplicationContext("total.xml");

Spring IOC 对象实例化

构造器实例化

注：**通过默认构造器创建空构造方法必须存在否则创建失败

ApplicationContext ac=new ClassPathXmlApplicationContext("spring.xml");
//通过getBean()方法得到实例化对象
//userFactory代表的是配置文件中bean标签的id属性
UserServices userServices= (UserServices) ac.getBean("userServices");
//方法调用
userServices.test();

 <bean id="userServices" class="com.shsxt.services.UserServices">

静态工厂实例化(了解)

<!--静态工厂-->
<bean   id="userFactory" class="com.shsxt.factory.UserFactory" factory-method="test"></bean>

实例化工厂实例化（了解）

<!--实例化工厂 
1.定义实例化工厂 bean 
2.引用工厂 bean 指定工厂创建方法(方法为非静态) -->
<bean id="instanceFactory" class="com.shsxt.factory.InstanceFactory"></bean> 
<bean id="userService" factory-bean="instanceFactory" factorymethod="createUserService"></bean>

Spring三种实例化bean的方式比较

方式一：通过bean 的缺省构造函数创建，当各个bean的业务逻辑相互比较独立的时候或者和外界关联较少的时候可以使用。
方式二：利用静态factory方法创建，可以统一管理各个bean的创建，如各个bean在创建之前需要相同的初始化处理，则可用这个factory方法险进行统一的处理等等。
方式三：利用实例化factory方法创建，即将factory方法也作为了业务bean来控制，
1可用于集成其他框架的bean创建管理方法，2能够使bean和factory的角色互换。

Spring IOC 注入（DI）

手动注入

set（方法）注入

1、属性字段都要提供set方法

		//业务对象UserDao   set注入
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    //常用对象String set注入
    private String host;
    public void setHost(String host) {
        this.host = host;
    }
    //基本类型Integer set注入
    private Integer port;

    public void setPort(Integer port) {
        this.port = port;
    }
   //List集合
    private List<String> list;

    public void setList(List<String> list) {
        this.list = list;
    }
    //List集合遍历
    public void printList(){
        list.forEach(s -> System.out.println(s));
    }

    //Set集合
    private Set<String> set;

    public void setSet(Set<String> set) {
        this.set = set;
    }
    //Set集合遍历
    public void printSet(){
        set.forEach(s -> System.out.println(s));
    }
    //Map集合
    public Map<String,Object> map;

    public void setMap(Map<String, Object> map) {
        this.map = map;
    }
    //Map遍历
    public void printMap(){
        map.forEach((k,v)-> System.out.println(k+","+v));
    }
    //Properties    set注入
    public Properties properties;

    public void setProperties(Properties properties) {
        this.properties = properties;
    }
    //properties遍历
    public void printPro(){
        properties.forEach((k,v)-> System.out.println(k+","+v));
    }

2、配置文件的bean标签设置property标签

<!--
        IOC通过property标签手动注入
            name：指bean对象的属性名
            ref：指定bean标签的id属性值
            value：具体的值（基本数据类型   常用数据类型|日期 集合）
    -->
    <bean id="userServices" class="com.shsxt.services.UserServices">
        <!--set注入-->
        <property name="userDao" ref="userDao"></property>
        <property name="host" value="192.168.28.249"></property>
        <property name="port" value="92"></property>

        <!--List集合注入-->
        <property name="list">
            <list>
                <value>北京</value>
                <value>上海</value>
                <value>深圳</value>
                <value>杭州</value>
                <value>成都</value>
            </list>
        </property>
        <!--Set集合注入-->
        <property name="set">
            <set>
                <value>北京BJ</value>
                <value>上海SH</value>
                <value>深圳SZ</value>
                <value>杭州HZ</value>
            </set>
        </property>
        <!--Map集合注入-->
        <property name="map">
            <map>
                <entry>
                    <key><value>周杰伦</value></key>
                    <value>稻香</value>
                </entry>
                <entry>
                    <key><value>林俊杰</value></key>
                    <value>可惜没有如果</value>
                </entry>

            </map>
        </property>
        <!--Properties注入-->
        <property name="properties">
            <props>
                <prop key="北京">天坛</prop>
                <prop key="杭州">西湖</prop>
                <prop key="上海">东方明珠</prop>
            </props>
        </property>
    </bean>

构造器注入

java代码

提供带参构造器

private UserDao01 userDao01;
    private StuDao stuDao;
    //常用类型String 构造器注入
    private String uname;
    //构造器
   /* public UserServices01(UserDao01 userDao01) {
        this.userDao01 = userDao01;
    }*/

   /* public UserServices01(UserDao01 userDao01, StuDao stuDao) {
        this.userDao01 = userDao01;
        this.stuDao = stuDao;
    }*/

   public UserServices01(UserDao01 userDao01, StuDao stuDao, String uname) {
        this.userDao01 = userDao01;
        this.stuDao = stuDao;
        this.uname = uname;
    }

XML配置

<!--
        IOC通过构造器注入：
            通过constructor-arg标签进行注入
            name:属性名称
            ref:指定bean标签的id属性值
            value：基本数据类型的值
            index：构造器中的参数下标
    -->
    <bean id="userServices01" class="com.shsxt.services.UserServices01">
        <constructor-arg ref="userDao01"></constructor-arg>
        <constructor-arg ref="stuDao"></constructor-arg>
        <constructor-arg name="uname" value="admin"></constructor-arg>
    </bean>
	<!--Bean对象依赖-->
    <bean id="userDao01" class="com.shsxt.dao.UserDao01"></bean>
    <bean id="stuDao" class="com.shsxt.dao.StuDao"></bean>

可能出现的问题：循环依赖

java代码：


public class AccountService {

    private RoleService roleService;

    //构造器
    public AccountService(RoleService roleService) {
        this.roleService = roleService;
    }

    /*public void setRoleService(RoleService roleService) {
        this.roleService = roleService;
    }*/

    public void test(){
        System.out.println("AccountService Test...");
        roleService.test();
    }
}


public class RoleService {
    private AccountService accountService;


    //构造器
    public RoleService(AccountService accountService) {
        this.accountService = accountService;
    }
    //
    /*public void setAccountService(AccountService accountService) {
        this.accountService = accountService;
    }*/

    public void test(){
        System.out.println("RoleService Test....");
        accountService.test();
    }
}

XML配置文件

	 <!--
        如果多个bean对象互相注入，则会出现循环依赖问题
        可通过set方法注入解决
    -->
	<bean id="roleService" class="com.shsxt.services.RoleService">
        <constructor-arg ref="accountService"></constructor-arg>
    </bean>
    <bean id="accountService" class="com.shsxt.services.AccountService">
        <constructor-arg ref="roleService"></constructor-arg>
    </bean>

解决构造器注入的循环依赖方法：将构造器注入改为set方法注入

java代码

public class RoleService {
    private AccountService accountService;
    /*
    //构造器
    public RoleService(AccountService accountService) {
        this.accountService = accountService;
    }
    */
    public void setAccountService(AccountService accountService) {
        this.accountService = accountService;
    }
    public void test(){
        System.out.println("RoleService Test....");
        accountService.test();
    }
}


public class AccountService {

    private RoleService roleService;
    /*
    //构造器
    public AccountService(RoleService roleService) {
        this.roleService = roleService;
    }
    */
    public void setRoleService(RoleService roleService) {
        this.roleService = roleService;
    }
    public void test(){
        System.out.println("AccountService Test...");
        roleService.test();
    }
}

	<!--修改为set方法注入-->
    <bean id="accountService" class="com.shsxt.services.AccountService">
        <property name="roleService" ref="roleService"></property>
    </bean>
    <bean id="roleService" class="com.shsxt.services.RoleService">
        <property name="accountService" ref="accountService"></property>
    </bean>

静态工厂注入(了解)

1、定义工厂类

//工厂类
public class StaticFactory {

    //定义一个TemService类型的静态方法
    public static TemService createTemService(){
        return new TemService();
    }
}

public class TemService {
    public void test(){
        System.out.println("TemService Test....");
    }
}

2、在配置文件中设置bean标签，指定工厂对象并设置对应的方法

<!--静态工厂注入的bean标签-->
    <bean id="temService" class="com.shsxt.factory.StaticFactory" factory-method="createTemService"></bean>

实例化工厂注入（了解）

1、定义工厂类

public class InstanceFactory {
    public TemService createTemService(){
        return new TemService();
    }
}

2、声明工厂bean标签，声明bean对象，指明工厂对象和工厂方法

<!--实例化工厂注入得bean标签-->
    <bean id="instanceFactory" class="com.shsxt.factory.InstanceFactory"></bean>
    <bean id="temService" factory-bean="instanceFactory" factory-method="createTemService"></bean>

自动注入

1、准备环境（修改配置文件）

<?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"
       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">
   
</beans>

2、开启自动注入

 <context:annotation-config />

##### 	3、给注入的bean对象添加注解 

###### 	@Resource注解

@Resource注解实现自动注入（反射）
1、默认根据属性字段名称查找对应的spring.xml文件中的bean标签
2、如果属性字段名称未找到，则通过类型（class类型）查找
3、属性可以提供set方法，也可以不提供set方法
4、注解可以声明在属性级别或set方法级别
5、@Resource可以设置name属性，name属性值必须与spring.xml中的bean标签的id属性值一致；如果设置了name属性值，就只会按照name属性值查找bean对象
6、当注入接口时，只有一个类实现了该接口则可以正常使用@Resource注入，如果多个类实现了该接口，则需要添加name属性@Resource（name=""）指定被需要被实例化的bean对象


```java
	@Resource
    private UserDao userDao;
    @Resource(name ="userDao")
    //set方法
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

@AutoWired注解

@AutoWired注解实现自动化注入：
     1、默认通过类型（class类型）查找bean对象   与属性字段的名称无关
     2、属性可以提供set方法，也可以不提供set方法
     3、注解可以声明在属性级别或set方法级别
     4、可以添加@Qualifier注解结合使用，通过value属性查找bean对象（@Qualifier（value=""）value属性值必须设置，且与spring.xml中的bean标签中的id属性值对应）

	@Autowired
    private AutoDao autoDao;
    @Autowired
    @Qualifier(value = "autoDao")
    //set方法
    public void setAutoDao(AutoDao autoDao) {
        this.autoDao = autoDao;
    }

Spring IOC扫描器

Spring IOC扫描器
                作用：将bean对象统一进行管理，简化开发配置，提高开发效率
                步骤：
                    1、设置自动扫描的范围
                        如果bean对象未在指定包范围，即使声明注解，也无法实例化
                    2、使用指定的注解(声明在类级别上)      bean对象的id属性默认是类的首字母小写
                        Dao层：
                            @Repository
                        Service层：
                            @Service
                        Controller层：
                            @Controller
                        开发的类实在不明确到底属于哪个层，可以使用@Component注解定义

                        注：开发过程中建议按照指定规则声明注解

1、设置自动扫描的范围

<!--设置自动扫描的范围-->
<context:component-scan base-package="com.shsxt" />

2、使用特定的注解

//dao层
@Repository
public class ResourceDao {
    public void test(){
        System.out.println("Hello ResourceDao......");
    }
}
//service层
@Service
public class ResourceService {
    public void test(){
        System.out.println("ResourceService。。。。。。。。");
    }
}
//Controller层
@Controller
public class UserController {
    public void ucontroller(){
        System.out.println("UserController");
    }
}
//其他层
@Component
public class UserFactory {
    public void test(){
        System.out.println("UserFactory.....");
    }
}

Bean的作用域

singleton作用域（单例作用域）

Spring IOC容器在实例化对象时，会将单例对象设置到单例缓存池中
    lazy-init属性(懒加载)
        如果为false，则在IOC容器启动时会实例化bean对象，默认是false
        如果为true，则IOC容器启动时不会实例化Bean对象，在使用bean对象时才会实例化

prototype作用域（原型作用域）

Spring IOC容器在实例化对象时，不会将单例对象设置到单例缓存池中，每一次实例都是一次新的对象

Web作用域

request作用域：
         在每一次请求实例化一个bean对象
session作用域：
          在每一次有效会话实例化一个bean对象
globalSession作用域：
          类似于session

Bean的生命周期

 Bean的生命周期包括Bean的定义、初始化、使用和销毁4个阶段
  	定义：
       	通过配置文件的方式来定义Bean的
        初始化（两种方式）：
            默认在IOC容器加载时，就实例化对象
            1、在配置文档中通过指定init-method属性完成
            2、实现org.springframework.beans.factory.InitializingBean接口
               使用：

               销毁：
                 步骤1：实现销毁方式(Spring容器会维护bean对象的管理，可以指定 bean对象的销毁所要 执行的方法)
<bean id="userServiceImpl"class="com.shsxt.service.impl.UserServiceImpl" initmethod="init" destroy-method="destroy"> </bean>
                 步骤2：通过AbstractApplicationContext 对象，调用其close方法实现bean的销毁过程。
 AbstractApplicationContext ctx=new ClassPathXmlApplicationContext("Springapplication.xml"); 	ctx.close();

化对象时，不会将单例对象设置到单例缓存池中，每一次实例都是一次新的对象


#### 	Web作用域

request作用域：
在每一次请求实例化一个bean对象
session作用域：
在每一次有效会话实例化一个bean对象
globalSession作用域：
类似于session


### Bean的生命周期

Bean的生命周期包括Bean的定义、初始化、使用和销毁4个阶段
定义：
通过配置文件的方式来定义Bean的
初始化（两种方式）：
默认在IOC容器加载时，就实例化对象
1、在配置文档中通过指定init-method属性完成
2、实现org.springframework.beans.factory.InitializingBean接口
使用：

           销毁：
             步骤1：实现销毁方式(Spring容器会维护bean对象的管理，可以指定 bean对象的销毁所要 执行的方法)

<bean id="userServiceImpl"class=“com.shsxt.service.impl.UserServiceImpl” initmethod=“init” destroy-method=“destroy”>
步骤2：通过AbstractApplicationContext 对象，调用其close方法实现bean的销毁过程。
AbstractApplicationContext ctx=new ClassPathXmlApplicationContext(“Springapplication.xml”); ctx.close();