SSM:二、spring笔记(一)：IOC(反转控制)、DI(依赖注入)、自动装配、作用域

IOC：控制反转

控制反转：类之间的关系，不用代码控制，而是由spring容器来控制，由定义的xml文件来控制，
控制权由代码翻转到容器里
表现形式：在初始化对象时，在代码无需写new，而是把类之间的关系写到配置文件中去，从下方的代码可以看出初始化SpingTest1，无需使用new对象。

DI:依赖注入

在代码运行时，如果我们要在一个类使用另一个类时，或者将bean的属性注入到setter方法中，称为依赖注入。

package main.java.com.zwh.pojo;

public class SpringTest1 {

    private String name;

    public SpringTest1(String name) {
        this.name = name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public SpringTest1() {

    }


    public void show () {
        System.out.println("你好啊！");
    }

    @Override
public String toString() {
    return "SpringTest1{" +
            "name='" + name + '\'' +
            '}';
}
}

 @Test
    public void test1 () {
        ApplicationContext ac = new ClassPathXmlApplicationContext("Application.xml");

        /*
        控制反转：类之间的关系，不用代码控制，而是由spring容器来控制，由上面的xml文件来控制，
        控制权由代码翻转到容器里

        表现形式：在初始化对象时，在代码无需写new，而是把类之间的关系写到配置文件中去，从下方的代码可以看出初始化SpingTest1
        无需使用new对象。
         */

        SpringTest1 s1 = (SpringTest1) ac.getBean("t1");
        System.out.println(s1);
        s1.show();

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

    <!--ioc容器简单配置-->
    <bean id="t1" class="main.java.com.zwh.pojo.SpringTest1">
        <!--name为Setter方法的属性，为反射机制-->
        <!--DI：依赖注入，把属性、构造器、类等注入到bean中-->
        <!--<property name="name" value="张三"></property>-->
        <!--构造器注入-->
        <constructor-arg value="李四" type="java.lang.String"></constructor-arg>
    </bean>

自动装配

自动装配，根据autowire自动装配，
byName:根据getter和setter方法进行查找向匹配的名字
byType:根据属性的类型来与字段进行匹配
缺点：一、代码可读性差，不容易维护，因为我们不得不在代码里找到依赖关系。
二、通用性不好，比方说我们不用spring了，那么我们就得一个一个删除。

• 定义三个类，分别为Address、Car、Person类

package main.java.com.zwh.SpringTest;

public class Address {

   private String city;
   private String street;

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }


    public String getStreet() {
        return street;
    }

    public void setStreet(String street) {
        this.street = street;
    }

    @Override
    public String toString() {
        return "Address{" +
                "city='" + city + '\'' +
                ", street='" + street + '\'' +
                '}';
    }
}

package main.java.com.zwh.SpringTest;

public class Car {

    private String brand;
    private double price;

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public Car() {
        System.out.println("Car的构造器!");
    }

    @Override
    public String toString() {
        return "Address{" +
                "brand='" + brand + '\'' +
                ", price=" + price +
                '}';
    }
}

package main.java.com.zwh.SpringTest;

public class Person {

    private String name;
    private Address address;
    private Car car;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", address=" + address +
                ", car=" + car +
                '}';
    }
}

       Person p = (Person) ac.getBean("person");
       System.out.println(p);

 <!--
    自动装配，根据autowire自动装配，
    byName:根据getter和setter方法进行查找向匹配的名字
    byType:根据属性的类型来与字段进行匹配
    -->
    <bean id="person" class="main.java.com.zwh.SpringTest.Person" p:name="Tom" autowire="byName">
    </bean>

    <bean id="address" class="main.java.com.zwh.SpringTest.Address" p:city="BeiJing" p:street="JianTian">
    </bean>

    <bean id="car" class="main.java.com.zwh.SpringTest.Car" p:brand="Audi" p:price="300000">
    </bean>

作用域

作用域：使用bean属性来配置scope作用域
singleton：默认值，容器初始时创建bean实例，在整个容器的生命周期内只创建这一个bean，当加载这个配置文件时，会自动装载。
prototype：原型的，容器初始时不创建bean实例，而在每次请求时都创建相应的bean。

<?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: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属性来配置scope作用域
   singleton：默认值，容器初始时创建bean实例，在整个容器的生命周期内只创建这一个bean，当加载这个配置文件时，会自动装载。
   prototype：原型的，容器初始时不创建bean实例，而在每次请求时都创建相应的bean。
   -->
   <!-- <bean id="car1" class="main.java.com.zwh.SpringTest.Car" scope="singleton">
        <property name="brand" value="Audi"></property>
        <property name="price" value="150000"></property>
    </bean>-->
    <bean id="car2" class="main.java.com.zwh.SpringTest.Car" scope="prototype">
        <property name="brand" value="Benz"></property>
        <property name="price" value="300000"></property>
    </bean>
</beans>

• 引入构造器

    public Car() {
        System.out.println("Car的构造器!");
    }

• 测试

 		Car car = (Car) ac.getBean("car2");
        Car car1 = (Car) ac.getBean("car2");
        System.out.println(car == car1);
        /*output:
        	singleton: Car的构造器!Car的构造器!true
        	prototype:Car的构造器!Car的构造器!true
        */

每天都在想你，emmmmm.