Day21SSM之SpringIOC

Spring的介绍

(1)Spring是什么？

• Spring 是分层的 Java SE/EE 应用 full-stack 轻量级开源框架

1. full-stack Service Dao web
2. 轻量级 按需添加模块
3. 开源 可以获取源代码
   以 IOC- （Inverse Of Control：反转控制）和 AOP- （Aspect Oriented Programming：面向切面编程）为内核

(2)有什么特点？

1. 提供了展现层 SpringMVC
2. 持久层 Spring JDBC
3. 还能整合开源世界众多著名的第三方框架和类库
4. 业务层事务管理 AOP
5. 方便解耦，简化开发 IOC
6. Java源码是经典学习范例
   逐渐成为使用最多的 Java EE 企业应用开源框架

(3)Spring架构体系

1. Test :用于测试使用
2. Core container：核心容器，就是用于装Java Bean对象
3. AOP：切面编程
4. Aspects：提供了与AspectJ的集成
5. Data access：数据访问。用于访问操作我们的数据库。支持持久层的操作。jdbcTemplate mybatis
6. Web：用于支持数据展示层，支持http请求
7. Transactions：用于支持事物处理。用于解决业务层的事物处理问题。 编程式事务管理和声明式事务管理.

Spring的IOC理论***

(1)什么是IOC

• 控制反转- （Inversion of Control，缩写为IoC）

1. 把原来new对象的这种方式转换成了,spring通过反射创建对象的方式
2. spring创建完的对象放到一个容器中,谁需要就给谁注入进去（获取对象并赋值给引用）
   简单说:把创建对象和管理对象的权利交给spring

Spring的IOC入门-环境搭建

1. 创建Project maven
2. 创建模块module maven
3. 配置依赖

pom.xml

<!--spring依赖 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.9.RELEASE</version>
    </dependency>

src\main\java\com\vission\bean\Person.java

package com.vission.bean;
public class Person {
private String name;
private int age;
.
.
.

src\main\resources\applicationContext.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 http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--    要让 spring容器给我创建一个person对象-->
    <!--    配置类名，用于反向创建对象-->
    <!--    同时给一个编号方便查找-->
    <bean id="person" class="com.vission.bean.Person" >
    <property name = "name" value = "胡书静的爹"></property>
        </bean>
</beans>

src\test\java\com\vission\TestSpringIOC.java

public class TestSpringIOC {
        @Test
        public void test01(){
            //1:创建ioc 容器对象  暂时看成map
            ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
            //2:给定配置文件的名称 applicationContext.xml
            //3:调用容器的getBean方法获取id对应的对象
            Person person = context.getBean("person",Person.class);
//            person.setName("胡书静的爹");
            System.out.println(person);
        }
}

运行一下看下结果

可以看到我在测试类中没用使用new创建对象，且person对象我也没有赋值，所有的值都是由application.xml替我创建好的，我只是通过ClasspathApplicationContext获取的对象

Spring的IOC入门-问题解答

1. 方法区别

context.getBean("id值", 类型.class);//无需转型
context.getBean("id值");//需转型

Person person = context.getBean("person",Person.Class);
Person person = (Person)context.getBean("person");

2. bean标签的属性

• id:bean标签的识别ID，理论上可以随便写
• class:你要上Spring给你创建哪个类的对象,需要写上该类的全路径名

id值取决于<bean>标签内id属性的值

3. 赋值的方式有两个

这是常见的JavaEE创建对象的且赋值的方法

 		Person person1 =  new Person();
        //设置方法
        person1.setId(1);
        System.out.println(person1);
        //构造方法赋值
        Person person2 =  new Person(1,"jack",20,new Date());
        System.out.println(person2);

• name:成员变量的名字
• value:成员变量的值

一个property标签最后会调一个对应的set方法

 <bean id="person2" class="com.visison.bean.Person" >
        <property name="id" value="10"/>
        <property name="name" value="rose"/>
        <property name="age" value="20"/>
    </bean>

通过构造方法创建对象

<!--    Person person2 =  new Person(1,"jack",20,new Date());-->
<!--    System.out.println(person2);-->
    <bean id="date1" class="java.util.Date"/>
    <bean id="person3" class="com.vission.bean.Person" >
            <constructor-arg name="id" value="10"/>
            <constructor-arg name="name" value="hello"/>
            <constructor-arg name="age" value="20"/>
            <constructor-arg name="birthday" ref="date1"/>
    </bean>

配置构造方法的参数的constructor-arg，如果有四个，就表示调的一个四个参数的构造方法。value可以赋上基本类型数据与String，但是其他对象，要使用ref表示在当前容器中查找一个已存在的对象

Spring的IOC入门-静态工厂造对象

1. 什么是静态工厂
   XxxFactory.get();
2. 通过调用静态方法获取bean对象

public class PersonFactory {
    public static Person getBean() {
        return new Person();//静态方法返回创建的对象
    }
}

这里我也没搞懂老师说的啥咱跳过吧
2020.10.13后续来了：由于我们的老师睡得比较早，所以我就没打扰他了，我自己找了点博客搞懂了补充下来

首先要明确一个概念，我们使用Spring框架最基本的对象不应该由我们创造，由框架替我们创造

自己画的图丑就丑了点呗
src\main\java\com\vission\Service\Isomthing.java

public interface Isomthing {
    public void doSomthing();
}

src\main\java\com\vission\Imp\IsomthingImp.java

public class IsomthingImp implements Isomthing {
    @Override
    public void doSomthing() {
        System.out.println("吃东西");
    }
}

src\main\java\com\vission\Factory\SomthingFactory.java

public class SomthingFactory {
    public static Isomthing getSomthing(){
        return new IsomthingImp();
    }
}

ApplicationContext.xml

<bean id="IsomthingImp" class="com.vission.Factory.SomthingFactory" factory-method="getSomthing" />

TestSpringIOC

public void test04() {
        // 创建容器对象，加载Spring配置文件
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        Isomthing isomthing = context.getBean("IsomthingImp",Isomthing.class);
        isomthing.doSomthing();
    }

Spring的IOC入门-单例和多例

1. 单例是什么？

• 内存中只有一个对象,每次获取到该对象的地址值一样.

2. 多实例是什么？

• 内存中的每个对象都是一个新的对象,他们的地址值都不同.
  问题: 每次获取对象的时候,spring是新创建一个对象还是始终给我们返回同一个对象.
  答案: spring默认的情况下创建的对象都是单例的. (每次返回的对象都是同一个)

有这么几个属性

scope="singleton" 单例(默认值)
        scope="prototype" 多例
        scope="request" 创建的对象放到request域中
        scope="session" 创建对象放到session对象

多实例

    <bean id="person" class="com.vission.bean.Person" scope="prototype"/>

单实例

    <bean id="person" class="com.vission.bean.Person" scope="singleton"/>

Spring生命周期(了解)

1. 生命周期

• 创建方法init
• 销毁方法destory
• 普通方法service

2. 属性

• init-method 当该对象初始化的时候该方法会自动执行
• destroy-method 当该对象即将销毁的时候会自动调用该方法

3. 测试

• context.close()关闭容器

src\main\java\com\vission\bean\Person2.java

public class Person2 {
    public void init(){
        System.out.println("哇哇...");
    }
    public void eat(){
        System.out.println("吃食堂...");
    }
    public void destory(){
        System.out.println("呜呜...");
    }
}

src\main\resources\applicationContext.xml

 <bean id="person2" class="com.vission.bean.Person2"
          init-method="init"
          destroy-method="destory"
    />

TestSpringIOC

    @Test
    public void test02() {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Person2 person2 = context.getBean("person2", Person2.class);
        person2.eat();
        context.close();
    }

创建的时候调用<bean>标签里init-method="init"方法
context.close调用<bean>标签里destroy-method="destory"方法