• Spring框架-IOC

    目录

    IOC概念和原理

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

    IOC操作Bean管理

    1.什么是Bean管理

    2.IOC基于xml操作Bean管理

    1、基于xml方式创建对象

     2、基于xml方式注入属性-使用set方法进行注入

    3.基于xml方式注入属性-使用有参数构造

    4、IOC操作Bean管理xml注入其他类型属性

    4.基于xml方式注入属性-外部注入bean方式注入属性

    5.基于xml方式注入属性-内部bean和级联赋值注入属性的方法

    6.xml注入集合属性

    7.工厂bean-FactoryBean 

     8.bean创建单例和多利

    8.、bean生命周期

    9.Bean的后置处理器 

    10.xml自动装配

    11.     IOC操作Bean管理（外部属性文件-数据库）

     基于注解方式操作bean管理

         1、什么是注解

        2.Spring针对Bean管理中创建对象提供注解

    ​编辑3、基于注解方式实现对象创建

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

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

    完全注解开发（了解SpringBoot会真正涉及）

    Spring框架概述

    1.Spring是轻量级的开源的JavaEE框架

    2.Spring可以解决企业应用开发的复杂性

    3.Spring有两个核心部分

            IOC：控制反转，把创建对象过程交给Spring进行管理

            Aop：面向切片，不修改源代码进行功能增强

    4.Spring特点

            方便解耦，简化开发

            Aop编程支持

            方便程序测试

            方便和替他框架进行整合

            方便进行实务操作

            降低API开发难度

    5.使用到的jar包

    IOC概念和原理

    1.什么是IOC

    • 控制反转，把对象创建和对象之间的调用过程，交给Spring管理

               在传统的 Java 应用中，一个类想要调用另一个类中的属性或方法，通常会先在其代码中通过 new Object() 的方式将后者的对象创建出来，然后才能实现属性或方法的调用。为了方便理解和描述，我们可以将前者称为“调用者”，将后者称为“被调用者”。也就是说，调用者掌握着被调用者对象创建的控制权。

    但在 Spring 应用中，Java 对象创建的控制权是掌握在 IoC 容器手里的，其大致步骤如下。

    1. 开发人员通过 XML 配置文件、注解、Java 配置类等方式，对 Java 对象进行定义，例如在 XML 配置文件中使用 标签、在 Java 类上使用 @Component 注解等。
    2. Spring 启动时，IoC 容器会自动根据对象定义，将这些对象创建并管理起来。这些被 IoC 容器创建并管理的对象被称为 Spring Bean。
    3. 当我们想要使用某个 Bean 时，可以直接从 IoC 容器中获取（例如通过 ApplicationContext 的 getBean() 方法），而不需要手动通过代码（例如 new Obejct() 的方式）创建。


    IoC 带来的最大改变不是代码层面的，而是从思想层面上发生了“主从换位”的改变。原本调用者是主动的一方，它想要使用什么资源就会主动出击，自己创建；但在 Spring 应用中，IoC 容器掌握着主动权，调用者则变成了被动的一方，被动的等待 IoC 容器创建它所需要的对象（Bean）。

    这个过程在职责层面发生了控制权的反转，把原本调用者通过代码实现的对象的创建，反转给 IoC 容器来帮忙实现，因此我们将这个过程称为 Spring 的“控制反转”。

    • 使用IOC目的：解耦合

    2.IoC 的工作原理

    在 Java 软件开发过程中，系统中的各个对象之间、各个模块之间、软件系统和硬件系统之间，或多或少都存在一定的耦合关系。

    若一个系统的耦合度过高，那么就会造成难以维护的问题，但完全没有耦合的代码几乎无法完成任何工作，这是由于几乎所有的功能都需要代码之间相互协作、相互依赖才能完成。因此我们在程序设计时，所秉承的思想一般都是在不影响系统功能的前提下，最大限度的降低耦合度。

    IoC 底层通过工厂模式、Java 的反射机制、XML 解析等技术，将代码的耦合度降低到最低限度，其主要步骤如下。

    1. 在配置文件（例如 Bean.xml）中，对各个对象以及它们之间的依赖关系进行配置；
    2. 我们可以把 IoC 容器当做一个工厂，这个工厂的产品就是 Spring Bean；
    3. 容器启动时会加载并解析这些配置文件，得到对象的基本信息以及它们之间的依赖关系；
    4. IoC 利用 Java 的反射机制，根据类名生成相应的对象（即 Spring Bean），并根据依赖关系将这个对象注入到依赖它的对象中。


    由于对象的基本信息、对象之间的依赖关系都是在配置文件中定义的，并没有在代码中紧密耦合，因此即使对象发生改变，我们也只需要在配置文件中进行修改即可，而无须对 Java 代码进行修改，这就是 Spring IoC 实现解耦的原理。

    3.结合例子理解IOC的解耦合

            需求：创建一个类的对象并调用它的方法

            原始方法：可以实现，但是耦合度太高了（两个类之间的联系太密切当其中一个类的信息改变，另一个类创建的对象也要跟着改变）

             工厂模式：解耦合，通过工厂模式降低了与UserDao的耦合度

            但并不能降到最低限度。所以引入IOC，可以将耦合度降到最低

    IOC过程：IOC思想是基于IOC容器完成的，IOC的容器底层就是对象工厂

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

            1.BeanFactory：IOC容器基本实现，是Spring内部使用的接口，不提供给开发人员使用，获取对象时创见对象

            2.ApplicationContext：BeanFactory的子接口，提供更多更强大的的功能，一般由开发人员进行使用，加载配置文件时就会把配置文件对象进行创建。

            3.ApplicationContext有两个实现类

                    ClassPathXmlApplicationContext:是src路径下的文件直接传文件名和后缀即可,加载类路径 ClassPath 下指定的 XML 配置文件，并完成 ApplicationContext 的实例化工作

                    FileSystemXmlApplicationContext:是盘下具体的一个文件，要把路径写清楚.加载指定的文件系统路径中指定的 XML 配置文件，并完成 ApplicationContext 的实例化工作

    IOC操作Bean管理（依赖注入）

    1.什么是Bean管理

          Bean管理是两个操作：Spring创建对象和注入属性

    在了解了 IoC 之后，我们还需要了解另外一个非常重要的概念：依赖注入。

    依赖注入（Denpendency Injection，简写为 DI）是 Martin Fowler 在 2004 年在对“控制反转”进行解释时提出的。Martin Fowler 认为“控制反转”一词很晦涩，无法让人很直接的理解“到底是哪里反转了”，因此他建议使用“依赖注入”来代替“控制反转”。

    在面向对象中，对象和对象之间是存在一种叫做“依赖”的关系。简单来说，依赖关系就是在一个对象中需要用到另外一个对象，即对象中存在一个属性，该属性是另外一个类的对象。

    例如，有一个名为 B 的 Java 类，它的代码如下。

    1. public class B {
    2.     String bid;
    3.     A a;
    4. }

    从代码可以看出，B 中存在一个 A 类型的对象属性 a，此时我们就可以说 B 的对象依赖于对象 a。而依赖注入就是就是基于这种“依赖关系”而产生的。

    我们知道，控制反转核心思想就是由 Spring 负责对象的创建。在对象创建过程中，Spring 会自动根据依赖关系，将它依赖的对象注入到当前对象中，这就是所谓的“依赖注入”。

    2.IOC基于xml操作Bean管理

    1、基于xml方式创建对象


              <！--配置User对象创建-->
              
             （1）在spring配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象创建
             （2）在bean标签有很多属性，介绍常用的属性
                     id属性：唯一标识
                     class属性：类全路径（包类路径）
             （3）创建对象时候，默认也是执行无参数构造方法完成对象创建

     2、基于xml方式注入属性-使用set方法进行注入


     （1）DI:依赖注入，就是注入属性
            第一种注入方式：使用set方法进行注入

    第一步：创建类：定义属性和对应的set方法

    1. public class Class02 {
    2. //    创建属性
    3.     private String bname;
    4.     private  String bauthor;
    5.  
    6. //    创建属性对应的set方法
    7.     public void setBname(String bname){
    8.         this.bname = bname;
    9.     }
    10.     public void setBauthor(String bauthor){
    11.         this.bauthor = bauthor;
    12.     }
    13.     public void testDemo(){
    14.         System.out.println(bname +","+bauthor);
    15.     }
    16. }

    第二步：在spring配置文件中配置对象创建，配置属性注入

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    5. <bean id = "book" class="com.java.spring5.Class02">
    6.     
    7.     <property name="bname" value="诗经">property>
    8.     <property name="bauthor" value="三国演义">property>
    9.  
    10. bean>
    11. beans>

    第三步：测试

    1. public class Test02 {
    2.     @Test
    3.     public void testadd2(){
    4. //        加载配置文件
    5.         ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
    6. //        获取配置的创建
    7.         Class02 book = context.getBean("book",Class02.class);
    8.         System.out.println(book);
    9.         book.testDemo();
    10.     }
    11. }

    3.基于xml方式注入属性-使用有参数构造

            第一步：创建类：定义属性，创建属性对应有参数的构造方法

    1. public class Class03 {
    2.     private String name1;
    3.     private  String bauthor1;
    4.  
    5.     public Class03(String name1,String bauthor1){
    6.         this.bauthor1 = bauthor1;
    7.         this.name1 = name1;
    8.     }
    9. //    使用有参构造器进行注入
    10.     public void testadd3(){
    11.         System.out.println(name1 +","+ bauthor1);
    12.     }
    13. }

    第二步：在spring配置文件中进行配置

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    5. <bean id = "book3" class="com.java.spring5.Class03">
    7.  
    8.     <constructor-arg name="name1" value="活着">constructor-arg>
    9.     <constructor-arg name="bauthor1" value="烟草">constructor-arg>
    10.  
    11. bean>
    12. beans>

    第三步：测试

    1. public class Test03 {
    2.     @Test
    3.     public void testaddd(){
    4.         ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
    5.         Class03 book3 = context.getBean("book3",Class03.class);
    6.         System.out.println(book3);
    7.         book3.testadd3();
    8.     }
    9. }

    4、IOC操作Bean管理xml注入其他类型属性

    （1）null值

    <property name = "address>

     （2）属性值包含特殊符号

       1把<>进行转义<: >:
        2把带特殊符号内容写到CDATA
     

    1.   <property name="address"
    2.     <value><！[CDATA[<<南京>>]]value>property> 

    4.基于xml方式注入属性-外部注入bean方式注入属性

    1）创建两个类service类和dao类

    •         创建userDao属性并创建他的set方法

    （2）在service调用dao里面的方法        

            在配置文件中创建service对象

            创建userdao的对象

            注入UserDao的属性

    （3）在spring配置文件中进行配置。

    1. public class UserService 
    2.    //创建UserDao类型属性，生成set方法
    3.    private UserDao userDao:
    4.  
    5.    public void setuserDao (UserDao userDao） {
    6.        this. userDao = userDao:
    7. }
    8.    public void add( 
    9.        System.out println(service add)
    10. }
    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    5. <bean id="userService" class="com.java.spring5.service.UserService">
    6.     
    7. <property name="userDao" ref="userdao">property>
    8. bean>
    9.     <bean id="userdao" class="com.java.spring5.dao.UserDaoEmp">bean>
    10. beans>

    5.基于xml方式注入属性-内部bean和级联赋值注入属性的方法

     （1）一对多关系：部门和员工
    一个部门有多个员工，一个员工属于一个部门,部门是一，员工是多

    （2）在实体类之间表示一对多关系，员工表示所属部门，使用对象类型属性进行

    （3）在spring中配置

    （4）测试

    内部bean

    1. //员工类
    2. public class Emp {
    3.     private Dept dept;
    4.  
    5.     public void setDept(Dept dept){
    6.         this.dept = dept;
    7.     }
    8.  
    9.     @Override
    10.     public String toString() {
    11.         return "Emp{" +
    12.                 "dept=" + dept +
    13.                 '}';
    14.     }
    15.     public void test(){
    16.         System.out.println(dept);
    17.     }
    18. }
    19.  
    20.  
    21. //部门类
    22. public class Dept {
    23.     @Override
    24.     public String toString() {
    25.         return "Dept{}";
    26.     }
    27. }
    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    6.     <bean id="emp" class="com.java.spring5.bean.Emp">
    8.     <property name="ename" value="lucy">property>
    9.     <property name="gender" value="女">property>
    11.         <property name="dept" >
    12.             <bean id="dept" class="com.java.spring5.bean.Dept">
    13.                 <property name="dname" value="安保部">property>
    14.             bean>
    15.         property>
    16. bean>
    17. beans>

     级联赋值的两种写法

    1

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    5.     <bean id="emp" class="com.java.spring5.bean.Emp">
    6.         
    7.         <property name="ename" value="lucy">property>
    8.         <property name="gender" value="女">property>
    10. <property name="dept" ref="dept1" >property>
    11.     bean>
    12.     <bean id="dept1" class="com.java.spring5.bean.Dept">
    13.         <property name="dname" value="财务部">property>
    14.  
    15.     bean>
    16. beans>

            输出：lucy 女 财务部

    2

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    5.     <bean id="emp" class="com.java.spring5.bean.Emp">
    6.         
    7.         <property name="ename" value="lucy">property>
    8.         <property name="gender" value="女">property>
    9.         
    10.         <property name="dept" ref="dept1" >property>
    12.         <property name="dept.dname" value="技术部">property>
    13.     bean>
    14.     <bean id="dept1" class="com.java.spring5.bean.Dept">
    15.         <property name="dname" value="财务部">property>
    16.  
    17.     bean>
    18. beans>

    6.xml注入集合属性

    • 注入数组类型属性
    • 注入List集合属性
    • 注入Map集合类型
    • 注入 set集合

            第一步：创建类，定义数组、list、map、set类型属性，生成对应的set方法

    1. public class Stu {
    2. //    数组类型属性
    3.     private String[] courses;
    4.  
    5.  
    6. //    List集合类型属性
    7.     private List list;
    8.  
    9.  
    10.  
    11. //    Map集合类型shuxing
    12.     private Map maps;
    13.  
    14.  
    15.  
    16. //    set集合类型属性
    17.     private Set sets;
    18.  
    19.  
    20.  
    21. //    学生所学的多门的课程
    22.     private ListcourseList;
    23.  
    24.     public void setCourseList(List courseList) {
    25.         this.courseList = courseList;
    26.     }
    27.  
    28.     public void setSets(Set sets) {
    29.         this.sets = sets;
    30.     }
    31.  
    32.     public void setCourses(String[] courses) {
    33.         this.courses = courses;
    34.     }
    35.  
    36.     public void setList(List list) {
    37.         this.list = list;
    38.     }
    39.  
    40.     public void setMaps(Map maps) {
    41.         this.maps = maps;
    42.     }
    43.     public void test(){
    44.         System.out.println(Arrays.toString(courses));
    45.         System.out.println(list);
    46.         System.out.println(maps);
    47.         System.out.println(sets);
    48.         System.out.println(courseList);
    49.     }
    50. }
    51.  
    52.  
    53.  
    54. public class Course {
    55.     private String cname;
    56.  
    57.     public void setCname(String cname) {
    58.         this.cname = cname;
    59.     }
    60.  
    61.     @Override
    62.     public String toString() {
    63.         return "Course{" +
    64.                 "cname='" + cname + '\'' +
    65.                 '}';
    66.     }
    67. }

            第二步：在spring配置文件进行配置

    •  数组类型属性注入 标签array
    •  list属性注入  标签list
    • Map属性注入 标签map、 entry
    • set属性注入 标签set
    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    5. <bean id="stu" class="com.java.spring5.collectiontype.Stu">
    7.     <property name="courses">
    8.         <array>
    9.             <value>javavalue>
    10.             <value>数据库value>
    11.         array>
    12.     property>
    14.     <property name="list">
    15.         <list>
    16.             <value>张三value>
    17.             <value>李四value>
    18.         list>
    19.  
    20.     property>
    22. <property name="maps">
    23.     <map>
    24.         <entry key="JAVA" value="java">entry>
    25.         <entry key="PHP" value="php">entry>
    26.     map>
    27. property>
    29.     <property name="sets">
    30.         <set>
    31.             <value>mysqlvalue>
    32.             <value>rediesvalue>
    33.         set>
    34.     property>
    35. bean>
    36.  
    37. beans>

    测试

    1. public class Testc1 {
    2.     @Test
    3.     public void testCollectin1(){
    4.         ApplicationContext context = new ClassPathXmlApplicationContext("beanc1.xml");
    5.         Stu stu = context.getBean("stu", Stu.class);
    6.         stu.test();
    7.  
    8.     }
    9. }

    但集合属性要考虑两个细节

    第一个细节：刚刚创建的都是String属性，如果我想在集合理放对象怎么放

    第二个细节：上述集合只能在id=stu中使用，不能再其他部分适用，如何提取集合将他变成公共部分

    第一个细节（list为例）

     （1）创建多个对象，和上述第一步创建内容一样

     （2）注入属性

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    6.     <bean id="cou" class="com.java.spring5.collectiontype.Stu">
    7.  
    8.         <property name="courseList">
    9.             <list>
    11.                 <ref bean="course1">ref>
    12.                 <ref bean="course2">ref>
    13.             list>
    14.         property>
    15.     bean>
    16.     <bean id="course1" class="com.java.spring5.collectiontype.Course">
    17.         <property name="cname" value="Spring5">property>
    18.     bean>
    19.     <bean id="course2" class="com.java.spring5.collectiontype.Course">
    20.         <property name="cname" value="Mybatis">property>
    21.     bean>
    22. beans>

    （3）测试

    1. public class Testc2 {
    2.     @Test
    3.     public  void testCollection2(){
    4.         ApplicationContext context = new ClassPathXmlApplicationContext("beanc2.xml");
    5.         Stu stu = context.getBean("cou",Stu.class);
    6.         stu.test();
    7.     }
    8. }

     

    第二个细节

    （1）创建多个对象，和上述第一步创建内容一样

     （2）创建提取类book

    1. //提取类
    2. public class Book {
    3.     private List list;
    4.  
    5.     public void setList(List list) {
    6.         this.list = list;
    7.     }
    8.  
    9.     @Override
    10.     public String toString() {
    11.         return "Book{" +
    12.                 "list=" + list +
    13.                 '}';
    14.     }
    15.     public void test3(){
    16.         System.out.println(list);
    17.     }
    18. }

     （3）在spring配置文件中引入名称空间util（注意上面xmlns和xsi配置）

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xmlns:p="http://www.springframework.org/schema/p"
    5.        xmlns:util="http://www.springframework.org/schema/util"
    6.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    7.                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
    9.     <util:list id="bookList">
    10.     <value>诗value>
    11.     <value>词value>
    12.     <value>歌value>
    13. util:list>
    14.  
    16.     <bean id="book" class="com.java.spring5.collectiontype.Book">
    17.         <property name="list" ref="bookList">property>
    18.     bean>
    19. beans>

    （4）测试

    1. public class Testc3 {
    2.  
    3.         @Test
    4.         public void testCollectin3(){
    5.             ApplicationContext context = new ClassPathXmlApplicationContext("beanc3.xml");
    6.            Book bo = context.getBean("book", Book.class);
    7.             bo.test3();
    8.  
    9.         }
    10. }

    7.工厂bean-FactoryBean 


           1、Spring有两种类型bean，一种普通bean，另外一种工厂bean-FactoryBean 
            2、普通bean：在配置文件中定义bean类型就是返回类型（上面的就是普通的）
            3、工厂bean：在配置文件定义bean类型可以和返回类型不一样
                 第一步创建类，让这个类作为工厂bean，实现接口FactoryBean 

                  第二步实现接口里面的方法，在实现的方法中定义返回的bean类型

    1. //实现factorybean实现接口
    2. public class MyBean implements FactoryBean {
    3. //返回类型方法，你定义的类型和返回类型不一样是由此方法决定
    4. //    类里定义的是MyBean类型，返回Course类型
    5.     @Override
    6.     public Course getObject() throws Exception {
    7.         Course course = new Course();
    8.         course.setCname("abc");
    9.         return course;
    10.     }
    11. //返回类型
    12.     @Override
    13.     public Class getObjectType() {
    14.         return null;
    15.     }
    16. //是否是一个单例
    17. //单例：所有请求都有一个对象来处理，因为没必要每个请求都建一个对象
    18.     @Override
    19.     public boolean isSingleton() {
    20.         return FactoryBean.super.isSingleton();
    21.     }
    22. }
    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    5.  
    6. <bean id="mybean" class="com.java.spring5.factorybean.MyBean">bean>
    7. beans>
    1. public class Testf1 {
    2.  
    3.         @Test
    4.         public void testf1(){
    5.             ApplicationContext context = new ClassPathXmlApplicationContext("beanf.xml");
    6. //         注意.class调用的类名，是返回值的类型
    7.             Course mybean = context.getBean("mybean", Course.class);
    8.             System.out.println(mybean);
    9.  
    10.  
    11.         }
    12. }

     8.bean创建单例和多利

    在Spring里，默认情况下，bean是单例

             Book1和 Book2输出内容相同

    如何设置单例还是多例
    （1）在spring配置文件bean标签里面有属性（scope）用于设置单实例还是多实例
    （2）scope属性值
    第一个值默认值，singleton，表示是单实例对象
    第二个值prototype，表示是多实例对象

    singleton和prototype区别
    第一 singleton单实例，prototype多实例
    第二设置scope值是singleton时候，加载spring配置文件时候就会创建单实例对象+
           设置scope值是prototype时候，不是在加载spring配置文件时候创建对象，在调用getBean方法时候创建多实例对象 

    8.、bean生命周期

    生命周期
     （1）从对象创建到对象销毁的过程
     2、bean生命周期，无后置配置处理器时
     （1）通过构造器创建bean实例（无参数构造）
     （2）为bean的属性设置值和对其他bean引用（调用set方法）
      （3）调用bean的初始化的方法（需要进行配置初始化的方法）
      （4）bean可以使用了（对象获取到了）
      （5）当容器关闭时候，词用bean的销毁的方法（需要进行配置销毁的方法）

    1. public class Orders {
    2.     private  String oname;
    3.  
    4.     public Orders() {
    5.         System.out.println("第一步：执行无参构造器创建bean实例");
    6.     }
    7.  
    8.     public void setOname(String oname) {
    9.         this.oname = oname;
    10.         System.out.println("第二步：调用set方法设置属性值");
    11.     }
    12. //    创建执行初始化的方法，但这只是一个普通的方法不会自己执行所以我们要进行配置
    13.     public void initMethod(){
    14.         System.out.println("执行初始化的方法");
    15.     }
    16. //    销毁方法
    17.     public void destory(){
    18.         System.out.println("第五步：这是一个销毁方法");
    19.     }
    20. }
    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    5.  
    7. <bean id="orders" class="com.java.spring5.bean.Orders" init-method="initMethod" destroy-method="destory">
    8.     <property name="oname" value="手机">property>
    9. bean>
    10.  
    11. beans>
    1. public class Testl1 {
    2.     @Test
    3.     public void life(){
    4. //        ApplicationContext不能调用close方法他的子类可以ClassPathXmlApplicationContext
    5.         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beanl1.xml");
    6.         Orders orders = context.getBean("orders", Orders.class);
    7.         System.out.println("第四步：获取创建bean实例对象");
    8.         System.out.println(orders);
    9.  
    10. //        手动销毁bean实例才能让配置调用
    11. context.close();
    12.  
    13.     }

    9.Bean的后置处理器 

    bean有后置处理器，bean生命周期有七步
     （1）通过构造器创建bean实例（无参数构造）
     （ 2）为bean的属性设置值和对其他bean引用（调用set方法）t
     （3）把bean实例传递bean后置处理器的方法postProessAfternitialization

     （4）调用bean的初始化的方法（需要进行配置初始化的方法）
    （5））把bean实例传递bean后置处理器的方法postProessAfternitialization
    （6）bean可以使用了（对象获取到了）
    （7）当容器关闭时候，调用bean的销毁的方法（需要进行配置销毁的方法）
    演示添加后置处理器效果
    1）创建类，实现接口BeanPostProessor 创建后置处理器

    1. public class Orders {
    2.     private  String oname;
    3.  
    4.     public Orders() {
    5.         System.out.println("第一步：执行无参构造器创建bean实例");
    6.     }
    7.  
    8.     public void setOname(String oname) {
    9.         this.oname = oname;
    10.         System.out.println("第二步：调用set方法设置属性值");
    11.     }
    12. //    创建执行初始化的方法，但这只是一个普通的方法不会自己执行所以我们要进行配置
    13.     public void initMethod(){
    14.         System.out.println("执行初始化的方法");
    15.     }
    16. //    销毁方法
    17.     public void destory(){
    18.         System.out.println("第五步：这是一个销毁方法");
    19.     }
    20. }
    21.  
    22.  
    23.  
    24.  
    25.  
    26. public class MyBeanFost implements BeanPostProcessor {
    27.  
    28.         @Override
    29.         public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    30.             System.out.println("这是初始化之前执行的方法");
    31.             return bean;
    32.         }
    33.  
    34.         @Override
    35.         public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    36.             System.out.println("这是初始化之后执行的方法");
    37.             return bean;
    38.         }
    39.     }
    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    5.  
    7. <bean id="orders" class="com.java.spring5.bean.Orders" init-method="initMethod" destroy-method="destory">
    8.     <property name="oname" value="手机">property>
    9. bean>
    12.     <bean id="myBeanPost" class="com.java.spring5.bean.MyBeanFost">bean>
    13. beans>
    1. public class Testl1 {
    2.     @Test
    3.     public void life(){
    4. //        ApplicationContext不能调用close方法他的子类可以ClassPathXmlApplicationContext
    5.         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beanl1.xml");
    6.         Orders orders = context.getBean("orders", Orders.class);
    7.         System.out.println("第四步：获取创建bean实例对象");
    8.         System.out.println(orders);
    9.  
    10. //        手动销毁bean实例才能让配置调用
    11. context.close();
    12.  
    13.     }

     

    10.xml自动装配

    什么是自动装配
    （1）根据指定装配规则（属性名称或者属性类），Spring自动将匹配的属性值进行注入 

    根据属性名或类型自动注入 

     第一步：创建类和属性

    1. public class Emp {
    2.  
    3.     private Dept dept;
    4.     public void setDept(Dept dept){
    5.         this.dept = dept;
    6.     }
    7.  
    8.     @Override
    9.     public String toString() {
    10.         return "Emp{" +
    11.                 "dept=" + dept +
    12.                 '}';
    13.     }
    14.     public void test(){
    15.         System.out.println(dept);
    16.     }
    17. }
    18.  
    19.  
    20.  
    21.  
    22. public class Dept {
    23.     @Override
    24.     public String toString() {
    25.         return "Dept{}";
    26.     }
    27. }
    28.

     第二步：配置xml属性

     实现自动装配
            bean标签属性autowire实现自动装配
            这个属性有两个值：byName根据属性名称注入,注入bean的值必须和类的属性名称一样
            byType：根据属性类型注入,同一个类型只能注册一次

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    7.     <bean id="emp" class="com.java.spring5.autowire.Emp" autowire="byName">
    9. bean>
    11.     <bean id="dept" class="com.java.spring5.autowire.Dept"  >bean>
    14. beans>

    11.     IOC操作Bean管理（外部属性文件-数据库）


              1、直接配置数据库信息
                    1）配置德鲁伊连接池
                     2）引入德鲁伊连接池依赖jar包

                   2.引入外部属性文件配置数据库连接池

                    1）创建外部属性文件，properties格式文件，写数据库信息

    1. prop.driverClass=com.mysql.cj.jdbc.Driver
    2. prop.url=jdbc:mysql://localhost:3306/test
    3. prop.name=root
    4. prop.password=123456

                    2）把外部properties属性文件引入到Spring配置文件中

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xmlns:context="http://www.springframework.org/schema/context"
    5.        xmlns:p="http://www.springframework.org/schema/p"
    6.  
    7.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    8.                             http://www.springframework.org/schema/context http://www.springframework.org/schema/beans/spring-context.xsd">
    9. <bean id="dtaSocutse" class="com.alibaba.druid.pool.DruidDataSource">
    11.     
    17.     <property name="driverClassName" value="${prop.driverClass">property>
    18.     <property name="url" value="${prop.url">property>
    19.     <property name="username" value="${prop.name">property>
    20.     <property name="password" value="${prop.password">property>
    21.  
    22.  
    23. bean>
    24. beans>

     基于注解方式操作bean管理

         1、什么是注解


              1）注解是代码特殊标记，格式：@注解名称（属性名称=属性值，属性名称=属性值..）
               2）使用注解，注解作用在类上面，方法上面，属性上面
               3）使用注解目的：简化xml配置


        2.Spring针对Bean管理中创建对象提供注解


             1）@Component：普通组建利用它都可以创建对象
              2)@Service：一般用在业务逻辑和service层
              3）@Controllei：用在web层
             4）@Repository：dao层

    四者使用时没什么区别，都是用来创建对象的且参数都为value，value为此bean的名字可不写，默认为第一个字母为小写的类名


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


    第一步引入依赖

    第二步开启组件扫描

    context:component-scan：关键字扫描

    base-package：要扫描的包名
       如果扫多个包，多个包使用号隔开  或扫描包上层目录

    

第三步创建类，在类上面添加创建对象注解
 在注解里面value属性值可以省略不写，
 默认值是类名称，首字母小写

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xmlns:context="http://www.springframework.org/schema/context"
    5.        xmlns:p="http://www.springframework.org/schema/p"
    6.  
    7.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    8.                             http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    10.     <context:component-scan base-package="com.java.spring5">context:component-scan>
    11.  
    12.  
    13. beans>
    1. //使用注解创建对象可使用四个注解中任何一个
    2. //在注解里面的value可以省略不写，他会默认类名的首字母小写
    3.  
    4. @Service(value = "userService")
    5.  
    6. public class UserService {
    7.  
    8. //    定义dao属性不需要添加set方法，添加属性注解即可
    9.  
    10.     public void add(){
    11.         System.out.println("service add....");
    12.     }
    13.  
    14.  
    15. }

     测试

    1. public class TestZhujie {
    2.     @Test
    3.     public void testServices(){
    4.         ApplicationContext context = new ClassPathXmlApplicationContext("beanzhu1.xml");
    5. //        这里不在是id值，因为value值相当于id值
    6.         UserService userService = context.getBean("userService", UserService.class);
    7.         System.out.println(userService);
    8.         userService.add();
    9.     }
    10. }

     细节：扫描类的选择

    红色：扫描包中的所有类

    彩色：扫描Controller注解中的所有类

     

    其中type有annotation，aspectj，assignable，custom，regex几种类型。

    其意义如下： 

    annotation：注解类型
    assignable_type：annotation：指定的类型
    aspectj：按照Aspectj的表达式，基本上不会用到
    regex：按照正则表达式
    custom：自定义规则

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

    （1）@Autowired：根据属性类型进行自动装配
     （2）@Qualifier：根据属性名称进行注入
     （3） @Resource: 可以根据类型注入，可以根据名称注入
      （4） @value:注入普通类型属性

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

    （1）@Autoired根据属性类型进行自动装配
    第一步service和dao对象创建，在senvice和dao类添加创建对象注解（@Service @Repository ）

    第二步在service注入da0对象，在sevice类添加dao类型属性，在属性上面使用注解（   @Autowired）

    1. @Service
    2. public class UserService {
    3.  
    4. //    定义接口属性,不需要添加set方法，添加注入属性注解
    5.     @Autowired
    6.     private UserDao userDao;
    7.     public void add(){
    8.         System.out.println("service add...");
    9.         userDao.add1();
    10.     }
    11. }
    12.  
    13.  
    14.  
    15. public interface UserDao {
    16.     public void add1();
    17. }
    18.  
    19. @Repository
    20. public class UserDaoEmp1 implements UserDao {
    21.     @Override
    22.     public void add1() {
    23.         System.out.println("dao");
    24.     }
    25. }

    测试

    1. public class Test1 {
    2.     @Test
    3.  
    4.     public void testServices(){
    5.         ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
    6. //        这里不在是id值，因为value值相当于id值
    7.         UserService userService = context.getBean("userService", UserService.class);
    8.         System.out.println(userService);
    9.         userService.add();
    10.     }
    11.  
    12. }

     （2）@Qualifier：根据属性名称进行注入（但必须结合@Autowired使用）

             当有多个接口实现类时Autowired没有办法确定是哪个实现类。所以结合@Qualifier根据名称进行注解

    （3）  @Resource: 可以根据类型注入，可以根据名称注入

     

     4） @value:注入普通类型属性


           输出：   name = abc 

    完全注解开发（了解SpringBoot会真正涉及）

            

  • 相关阅读:
    Copilot：AI自动写代码，人工智能究竟还能取代什么？
    SCI论文写作（一） | SCI论文的文献综述(Literature Review)部分
    Visual Studio 线性表的链式存储节点输出引发异常：读取访问权限冲突
    Pandas文本处理
    你不知道的JavaScript---异步：现在与未来
    炸机不可怕，可怕的是你不知道为什么炸
    hadoop宕机的处理方法
    一文讲透 RocketMQ 消费者是如何负载均衡的
    【目标锁定特效】（Html+JS+CSS+效果+代码）
    【JAVA基础——JAVA虚拟机JVM】
  • 原文地址：https://blog.csdn.net/m0_56223907/article/details/126881082