spring简介和IOC

spring

框架概述

1. Spring是轻量级的开源的JavaEE框架
2. Spring可以解决企业开发的复杂性
3. Spring有两个核心部分: IOC和Aop

​ (1)IOC:控制反转,把创建对象的过程交给spring进行管理

​ (2)Aop:面向切面,不修改源代码进行功能增强

4. Spring特点

   (1)方便解耦,简化开发

   (2)Aop编程支持

   (3)方便程序测试

   (4)方便和其他框架整合

   (5)方便进行事务操作

   (6)降低API开发难度

IOC

1.什么是IOC

(1) 控制反转,把对象创建和对象之间的调用过程,交给Spring进行管理

(2) 使用IOC目的:为了降低耦合度

2.IOC底层原理

(1) xml解析,工厂模式,反射

工厂模式

例: 一个UserService类,一个UserDao类,UserService中的execute()方法想调用UserDao中的add()方法

传统方式

class UserService{
    execute(){
        UserDao dao = new UserDao();//直接newUserDao对象
        dao.add();
    }
}

class UserDao{
    add(){
        ...
    }
}

//这样做两个类之间耦合度过高,如果UserDao被很多个类调用,UserDao路径改变,则其他类都需要改变

工厂模式

class UserService{
    execute(){
        UserDao dao = new UserFacotry.getDao();
        dao.add();
    }
}

class UserDao{
    add(){
        ...
    }
}

class UserFactory{//创建一个工厂类
    public static UserDao getDao(){
        return new UserDAO();
    }
}

//降低了耦合度,如果路径改变,只需要修改UserFactory类,但不能做到完全没有耦合.
    

IOC实现过程

第一步 xml配置文件,配置创建的对象

<bean id="dao" class="com.yzy.UserDao"></bean>

第二步 创建工厂类

class UserFactory{//创建一个工厂类
    public static UserDao getDao(){
        String classValue = class属性值;//xml解析
        Class clazz = Class.forName(classValue)//通过反射创建对象
        reurn (UserDao)clazz.newInstance();
        
    }
}
//这样做之后,假如UserDao路径变了,只需要修改xml配置文件中的路径,进一步降低耦合度

3.IOC接口

(1)IOC思想基于IOC容器完成,IOC容器底层就是对象工厂

(2)Spring提供IOC容器实现两种方式(两个接口):

BeanFactory: IOC容器基本实现,是Spring内部的使用接口,一般不提供开发人员使用

*加载配置文件时不会创建对象,在获取(使用)对象时才去使用对象

ApplicationContext: BeanFactory接口的子接口,提供更多更强大的功能,一般由开发人员进行使用

*加载配置文件时就会把配置文件对象进行创建

//Spring框架一般结合Web项目来操作,在服务器启动时将这些资源创建更为合适,所以ApplicationContext更优.

4.IOC操作Bean管理

1.什么是Bean管理

​ (1)Spring创建对象

​ (2)Spring注入属性

2.Bea管理操作有两种方式

​ (1)基于xml配置文件方式实现

​ (2)基于注解方式实现

IOC操作Bean管理(基于xml方式)

1.基于xml方式创建对象

<bean id="dao" class="com.yzy.UserDao"></bean>

2.基于xml方式注入属性

​ (1)DI:依赖注入,就是注入属性,是IOC的一种具体实现

第一种注入方式:使用set方法注入:

• 创建类,定义属性和对应的set方法

• 在spring配置文件配置对象创建,配置属性注入

  <bean id="book" class="com.yzy.spring5.Book">
          <property name="bookName" value="易筋经"></property>
          <property name="author" value="达摩老祖"></property>
      </bean>
  

第二种注入方式:使用有参构造进行注入

• 创建类,定义属性,创建属性对应有参数构造方法

• 在spring配置文件中进行配置

  <bean id="orders" class="com.yzy.spring5.Orders">
          <constructor-arg name="orderName" value="电脑"></constructor-arg>
          <constructor-arg name="address" value="China"></constructor-arg>
      </bean>
  

第三种注入方式:p名称空间注入(底层是set方法)

• 添加p名称空间在配置文件中

  <beans xmlns="http://www.springframework.org/schema/beans"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns:p="http://www.springframework.org/schema/p" <!--这一句话-->
         xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  

• 进行属性注入,在bean标签里面进行操作

<bean id="book" class="com.yzy.spring5.Book" p:bookName="九阳神功" p:author="无名氏">
    </bean>

IOC操作Bean管理(xml注入其他类型属性)

• 字面量(变量固定的值)

  (1)null值

  <property name="address"><null/></property>
  

  (2)属性值包含特殊符号

  //例如<南京>的左右尖括号会干扰xml文件读取
  <property name="address">
                  <value><![CDATA[<南京>]]></value>
              </property>
  

• 外部bean

  public class UserService {
  
      private UserDao userDao;
      public void setUserDao(UserDao userDao){
          this.userDao = userDao;
      }
  
      public void add(){
          System.out.println("service add().......");
          userDao.update();
      }
  }
  
  public class UserDaoImpl implements UserDao{
      @Override
      public void update() {
          System.out.println("dao update()......");
      }
  }
  

  为了在UserService类中调用UserDaoImpl的方法(),给UserService注入UserDao(外部bean)

  <!--1. service和dao对象创建-->
      <bean id="userService" class="com.yzy.spring5.service.UserService">
          <!--注入userDao对象-->
          <property name="userDao" ref="userDao"></property>
      </bean>
      <bean id="userDao" class="com.yzy.spring5.dao.UserDaoImpl"></bean>
  

• 内部bean

  //员工类
  public class Emp {
      private String name;
      private String gender;
      private Dept dept;
  
      public void setName(String name) {
          this.name = name;
      }
  
      public void setGender(String gender) {
          this.gender = gender;
      }
  
      public void setDept(Dept dept) {
          this.dept = dept;
      }
  }
  
  //部门类
  public class Dept {
      private String dName;
  
      public void setdName(String dName) {
          this.dName = dName;
      }
  }
  

  <bean id="emp" class="com.yzy.spring5.bean.Emp">
          <property name="name" value="lucy"></property>
          <property name="gender" value="女"></property>
          <property name="dept">
              <bean id="dept" class="com.yzy.spring5.bean.Dept">
                  <property name="dName" value="安保部"></property>
              </bean>
          </property>
      </bean>
  <!--内部嵌套bean-->
  

  IOC操作Bean管理(xml注入集合属性)

  <bean id="stu" class="com.yzy.spring5.collectiontype.Stu">
      <!--数组类型属性注入-->
      <property name="courses">
          <array>
              <value>java课程</value>
              <value>数据库课程</value>
          </array>
      </property>
      <!--list类型属性注入-->
      <property name="list">
          <list>
              <value>张三</value>
              <value>小三</value>
          </list>
      </property>
      <!--map类型属性注入-->
      <property name="maps">
          <map>
              <entry key="JAVA" value="java"></entry>
              <entry key="PHP" value="php"></entry>
          </map>
      </property>
      <!--set类型属性注入-->
      <property name="sets">
          <set>
              <value>MySQL</value>
              <value>Redis</value>
          </set>
      </property>
  </bean>
  

  拓展

  • 在集合里面设置对象类型值

    public class Course {
        private String name;
    
        public void setName(String name) {
            this.name = name;
        }
    }
    
    public class Stu {
        private List<Course> courseList;
    
        public void setCourseList(List<Course> courseList) {
            this.courseList = courseList;
        }
    

    <bean id="stu" class="com.yzy.spring5.collectiontype.Stu">    
    	<property name="courseList">
            <list>
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>
            </list>
        </property>
    </bean>
    
        <!--创建多个course对象-->
        <bean id="course1" class="com.yzy.spring5.collectiontype.Course">
            <property name="name" value="Spring5框架课程"></property>
        </bean>
        <bean id="course2" class="com.yzy.spring5.collectiontype.Course">
            <property name="name" value="MyBatis框架"></property>
        </bean>
    

  • 把集合注入部分提取出来

    （1）在 spring 配置文件中引入名称空间 util

    <?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:util="http://www.springframework.org/schema/util"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                               http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
    

    （2）使用 util 标签完成 list 集合注入提取

    <util:list id="bookList">
            <value>易筋经</value>
            <value>九阴真经</value>
            <value>九阳神功</value>
        </util:list>
    <!--这样在其他类给list属性赋值也能引用bookList进行赋值-->
    
    
        <bean id="book" class="com.yzy.spring5.collectiontype.Book">
            <property name="list" ref="bookList"></property>
        </bean>
    </beans>
    

  IOC操作Bean管理(FactoryBean)

  • Spring有两种类型bean,一种普通bean,另外一种工厂bean(FactoryBean)

  • 普通bean:在配置文件中定义 bean 类型就是返回类型

  • 工厂bean:在配置文件定义 bean 类型可以和返回类型不一样

  第一步:创建类，让这个类作为工厂 bean，实现接口 FactoryBean

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

  public class MyBean implements FactoryBean<Course> {
      @Override
      public Course getObject() throws Exception {
          Course course= new Course();
          course.setName("abc");
          return course;
      }
  
      @Override
      public Class<?> getObjectType() {
          return null;
      }
  
      @Override
      public boolean isSingleton() {
          return false;
      }
  }
  
  @Test
      public void testCollection3(){
          ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
          Course course = context.getBean("myBean", Course.class);
          System.out.println(course);
  
      }
  

  <bean id="myBean" class="com.yzy.spring5.factorybean.MyBean"></bean>
  

  IOC操作Bean(bean作用域)

  • 在Spring里面,默认情况下,bean是单实例对象

    @Test
        public void testCollection2(){
            ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
            Book book1 = context.getBean("book", Book.class);
            Book book2 = context.getBean("book", Book.class);
            System.out.println(book1);
            System.out.println(book2);
        }
    //结果是:
    //com.yzy.spring5.collectiontype.Book@6483f5ae
    //com.yzy.spring5.collectiontype.Book@6483f5ae
    
    //证明默认情况下是单实例
    

  • 在Spring里面,可以设置创建bean实例是单实例还是多实例

    (1)在spring配置文件bean标签里面有属性scope用于设置单实例还是多实例

    (2)scope属性值: 1.singleton,表示单实例 2.prototype,表示是多实例对象

    <bean id="book" class="com.yzy.spring5.collectiontype.Book" scope="prototype">
            <property name="list" ref="bookList"></property>
        </bean>
    
    //修改为scope="prototype"后,程序结果为:
    //com.yzy.spring5.collectiontype.Book@b9afc07
    //com.yzy.spring5.collectiontype.Book@382db087
    //证明修改为多实例对象
    

    (3)singlton 和 prototype区别

    ​ 第一: singlton单实例,prototype多实例

    ​ 第二: 设置scope值是singleton时,加载spring配置文件时就会创建单实例对象

    ​ 设置scope值是prototype时,在调用getBean方法时才创建多实例对象

IOC操作Bean管理(bean生命周期)

• 生命周期

  从对象创建到对象销毁的过程

• bean生命周期

  (1)通过构造器创建bean实例(执行无参数构造)

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

  (3)调用bean的初始化的方法(需要进行配置)

  (4)bean可以使用了(对象获取到了)

  (5)当容器关闭时候,调用bean的销毁方法(需要进行配置销毁的方法)

  public class Orders {
      private String name;
  
      public Orders() {
          System.out.println("第一步 执行无参数构造,创建bean实例");
      }
  
      public void setName(String name) {
          this.name = name;
          System.out.println("第二步 调用set方法设置属性值");
      }
  
      //创建执行的初始化的方法
      public void initMethod(){
          System.out.println("第三步 执行初始化的方法");
      }
  
      //创建执行的销毁方法
      public void destroyMethod(){
          System.out.println("第五步 执行销毁的方法");
      }
  }
  
  @Test
      public void testCollection4(){
          ApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");
          Orders orders = context.getBean("orders", Orders.class);
          System.out.println("第四步 获取创建bean实例对象");
  
          //手动让bean销毁
          ((ClassPathXmlApplicationContext)context).close();
      }
  

  <bean id="orders" class="com.yzy.spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
          <property name="name" value="手机"></property>
      </bean>
  

  结果为:

  第一步 执行无参数构造,创建bean实例
  第二步 调用set方法设置属性值
  第三步 执行初始化的方法
  第四步 获取创建bean实例对象
  第五步 执行销毁的方法

• bean的后置处理器(加上bean的后置处理器,bean的生命周期有七步操作)

  (1)通过构造器创建bean实例(执行无参数构造)

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

  (!)把bean实例传递bean后置处理器的方法: postProcessBeforeInitialization

  (3)调用bean的初始化的方法(需要进行配置)

  (!)把bean实例传递bean后置处理器的方法: postProcessAfterInitialization

  (4)bean可以使用了(对象获取到了)

  (5)当容器关闭时候,调用bean的销毁方法(需要进行配置销毁的方法)

• 演示添加后置处理器效果

  创建类,实现接口BeanPostProcessor,创建后置处理器

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

  <bean id="orders" class="com.yzy.spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
          <property name="name" value="手机"></property>
      </bean>
  
      <!--配置后置处理器-->
      <bean id="myBeanPost" class="com.yzy.spring5.bean.MyBeanPost"></bean>
  

  添加完后置处理器后,该xml配置文件中的所有类都会拥有后置处理器,所以如果继续执行上面的testCollection4()方法,结果为:

  第一步 执行无参数构造,创建bean实例
  第二步 调用set方法设置属性值
  在初始化之前执行的方法
  第三步 执行初始化的方法
  在初始化之后执行的方法
  第四步 获取创建bean实例对象
  第五步 执行销毁的方法

IOC操作Bean管理(xml自动装配)

• 什么是自动装配

  根据指定装配规则(属性名称或者属性类型),Spring自动将匹配的属性值进行注入

• 演示自动装配过程

  (1)根据属性名称自动注入

      <!--实现自动装配
          bean标签属性autowire,配置自动装配
          autowire属性常用两个值:
              byName根据属性名注入,注入值bean的id值和类属性名称要一样
              byType根据属性类型注入
      -->
      <bean id="emp" class="com.yzy.spring5.autowire.Emp" autowire="byName">
      </bean>
      <bean id="dept" class="com.yzy.spring5.autowire.Dept"></bean>
  

  (2)根据属性类型自动注入

  <bean id="emp" class="com.yzy.spring5.autowire.Emp" autowire="byType">
  

IOC操作Bean管理(外部属性文件)

• 直接配置数据库信息

  (1)配置德鲁伊连接池

  (2)引入德鲁伊连接池依赖jar包

  <!--直接配置连接池-->
      <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/userDb"></property>
          <property name="username" value="root"></property>
          <property name="password" value="yzy"></property>
      </bean>
  

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

  (1)创建外部属性文件,properties格式文件,写数据库信息

prop.driverClass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/userDb
prop.userName=root
prop.password=yzy

​ (2)把外部properties属性文件引入spring配置文件中

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

​ (3)在spring配置文件使用标签引入外部属性文件

    <!--引入外部属性文件-->
    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>

    <!--配置连接池-->
        <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
            <property name="driverClassName" value="${prop.driverClass}"></property>
            <property name="url" value="${prop.url}"></property>
            <property name="username" value="${prop.userName}"></property>
            <property name="password" value="${prop.password}"></property>
        </bean>

IOC操作Bean管理(基于注解方式)

• 什么是注解

  (1)注解是代码特殊标记,格式: @注解名称(属性名称=属性值,属性名称=属性值…)

​ (2)使用注解,注解可以作用在类上面,方法上面,属性上面

​ (3)使用注解的目的: 简化xml配置

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

  (1)@Component

  (2)@Service

  (3)@Contorller

  (4)@Repository

  *上面四个注解功能是一样的,都可以用来创建bean实例

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

  第一步:引入依赖

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

​ 第二步:开启组件扫描

    <!--开启组件扫描
         如果扫描多个包,使用逗号隔开,或者扫描上层目录
    -->
    <context:component-scan base-package="com.yzy.spring5.dao,com.yzy.spring5.service"></context:component-scan>

​ 第三步:创建类,在类上面添加创建对象注解

//注解里面的value属性值可以省略不写,默认值是类名称,首字母小写
@Service(value = "userService")  //相当于<bean id="userService" class=".."
public class UserService {


    public void add(){
        System.out.println("service add...");
    }
}

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

  (1)@AutoWired : 根据属性类型进行自动装配

  //注解里面的value属性值可以省略不写,默认值是类名称,首字母小写
  @Service(value = "userService")  //<bean id="userService" class=".."
  public class UserService {
      //不需要set方法,已经封装好了
      @Autowired //根据类型进行注入
      private UserDao userDao;
  
      public void add(){
          System.out.println("service add...");
          userDao.add();
      }
  }
  
  
  @Repository(value = "userDaoImpl1")
  public class UserDaoImpl implements UserDao{
      @Override
      public void add() {
          System.out.println("dao add....");
      }
  }
  

  (2)@Qualifier : 根据属性名称进行注入,要和@AutoWired一起使用

  //userDao作为接口可以有多个实现类,如果通过类型注入,会无法判断注入哪个类,所以需要属性名称注入
  @Service(value = "userService")  //<bean id="userService" class=".."
  public class UserService {
      //不需要set方法,已经封装好了
      @Autowired //根据类型进行注入
      @Qualifier(value = "userDaoImpl1")//根据名称注入
      private UserDao userDao;
      
      
      public void add(){
          System.out.println("service add...");
          userDao.add();
      }
  }
  

  (3)@Resource : 可以根据类型注入,可以根据名称注入(该注解由javax提供,其余注解由Spring提供)

  //注解里面的value属性值可以省略不写,默认值是类名称,首字母小写
  @Service(value = "userService")  //<bean id="userService" class=".."
  public class UserService {
  //    @Resource //根据类型注入
      @Resource(name = "userDaoImpl1")//根据名称注入
      private UserDao userDao;
  
      public void add(){
          System.out.println("service add...");
          userDao.add();
      }
  }
  

  (4)@Value : 注入普通类型属性

  //注解里面的value属性值可以省略不写,默认值是类名称,首字母小写
  @Service(value = "userService")  //<bean id="userService" class=".."
  public class UserService {
  //    @Resource //根据类型注入
      @Resource(name = "userDaoImpl1")//根据名称注入
      private UserDao userDao;
  
      @Value(value = "abc")  //name = "abc"
      private String name;
  
      public void add(){
          System.out.println("service add...");
          userDao.add();
          System.out.println(name);
      }
  }
  

• 完全注解开发

  (1)创建配置类,替代xml配置文件

  @Configuration  //将该类作为配置类,替代xml文件
  @ComponentScan(basePackages = {"com.yzy"}) //组件扫描
  public class SpringConfig {
      
  }
  

  (2)编写测试类

  @Test
      public void testService2(){
          ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
          UserService userService = context.getBean("userService", UserService.class);
          System.out.println(userService);
          userService.add();
      }
  

serService") //<bean id=“userService” class=“…”
public class UserService {
// @Resource //根据类型注入
@Resource(name = “userDaoImpl1”)//根据名称注入
private UserDao userDao;

  @Value(value = "abc")  //name = "abc"
  private String name;

  public void add(){
      System.out.println("service add...");
      userDao.add();
      System.out.println(name);
  }

}

- 完全注解开发

(1)创建配置类,替代xml配置文件

```java
@Configuration  //将该类作为配置类,替代xml文件
@ComponentScan(basePackages = {"com.yzy"}) //组件扫描
public class SpringConfig {
    
}

(2)编写测试类

@Test
    public void testService2(){
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        UserService userService = context.getBean("userService", UserService.class);
        System.out.println(userService);
        userService.add();
    }