spring框架（IOC）_01_ioc 解耦 dog cat-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_41656303/article/details/109189324

1.spring的介绍

spring的2大核心思想：
ioc: 控制反转，就是工厂模式。 将对象的创建和销毁交给了spring
aop:面向切面的编程，就是动态代理。 在不修改源码的情况下，对功能进行增强。

2.spring的ioc

2.1 工厂模式

2.1.2 反射解耦

基于多个实现类需要进行功能切换，我们只需要修改配置文件，不需要改java代码，所以不需要重新编译。

UserServlet

package com.itheima.web;

import com.itheima.service.UserService;
import com.itheima.service.impl.UserServiceImpl;
import com.itheima.service.impl.UserServiceImpl2;

import java.util.ResourceBundle;

public class UserServlet {

    public static void main(String[] args) {
        //请求过来，调用servlet的service

        //UserService userService = new UserServiceImpl2();

        //读取配置文件的内容
        ResourceBundle rb = ResourceBundle.getBundle("beans");
        String classPath = rb.getString("classPath");

        UserService userService = null;
        try {

            userService = (UserService) Class.forName(classPath).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        userService.login();
    }
}

UserService

package com.itheima.service;

public interface UserService {
    public void login();
}

UserServiceImpl

package com.itheima.service.impl;

import com.itheima.service.UserService;

public class UserServiceImpl implements UserService {
    @Override
    public void login() {
        System.out.println("登录功能");
    }
}

UserServiceImpl2

package com.itheima.service.impl;

import com.itheima.service.UserService;

public class UserServiceImpl2 implements UserService {
    @Override
    public void login() {
        System.out.println("登录功能扩展");
    }
}

beans.properties

classPath=com.itheima.service.impl.UserServiceImpl2

2.1.2 多例工厂模式

bean.properties

userService=com.it.service.impl.UserServiceImpl
roleService=com.it.service.impl.RoleServiceImpl

BeansFacoty

package com.it.utils;

import com.it.service.RoleService;
import com.it.service.UserService;

import java.util.ResourceBundle;

/**
 * 工厂模式：专门用来创建java对象的工具类。
 *
 *      将java对象的创建由new的方式 替换成了  反射+配置的方式来创建对象。
 *
 *
 *    工厂模式的好处：
 *      1.解耦
 *      2.可以对java中的对象进行管理。
 *
 *
 *    注意：
 *      在没有解耦的情况下，我们以前使用对象，都是自己new
 *      现在有了工厂模式，我们使用对象，都是工厂去创建，我们从工厂去获取。
 *      对象的创建权利由我们自己创建，交给了工厂创建。这就是ioc
 *
 */
public class BeansFactory {

    public static Object getBean(String beanName){
        //1.读取配置
        ResourceBundle rb = ResourceBundle.getBundle("beans");
        String classPath = rb.getString(beanName);
        //2.反射机制创建对象
        Object obj = null;
        try {
            obj = Class.forName(classPath).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return obj;
    }

    public static void main(String[] args) {
        UserService userService = (UserService) getBean("userService");
        System.out.println(userService);
        RoleService roleService = (RoleService)getBean("roleService");
        System.out.println(roleService);
    }
}

2.1.3 单例工厂

package com.it.utils;

import com.it.service.RoleService;
import com.it.service.UserService;

import java.util.HashMap;
import java.util.ResourceBundle;
import java.util.Map;

/**
 * 工厂模式：专门用来创建java对象的工具类。
 *
 *      将java对象的创建由new的方式 替换成了  反射+配置的方式来创建对象。
 *
 *
 *    工厂模式的好处：
 *      1.解耦
 *      2.可以对java中的对象进行管理。
 *              单例和多例
 *
 *              单例：一个类创建的对象只有一个。节省资源。
 *              多例：一个类创建的对象可以有多个。
 *
 *
 *              如果存在线程安全问题的情况下，不能采用单例。
 *              什么情况下会出现线程安全问题？
 *              1.多并发
 *              2.多个线程抢占一个资源，并且做了修改。
 *
 *
 *    注意：
 *      在没有解耦的情况下，我们以前使用对象，都是自己new
 *      现在有了工厂模式，我们使用对象，都是工厂去创建，我们从工厂去获取。
 *      对象的创建权利由我们自己创建，交给了工厂创建。这就是ioc
 *
 */
public class BeansFactory {

    /**
     * 多例工厂
     *
     *  此时我们的工厂创建的是service对象
     *   1.是否是并发的？  是。
     *   2.是否涉及多个线程抢占一个资源，并且修改了service。  不涉及service的成员变量的更改
     *
     *   是否存在线程安全问题呢？不存在
     *   使用单例，性能更好。
     *
     *
     * @param beanName
     * @return
     */
    public static Object getBean(String beanName){
        //1.读取配置
        ResourceBundle rb = ResourceBundle.getBundle("beans");
        String classPath = rb.getString(beanName);
        //2.反射机制创建对象
        Object obj = null;
        try {
            obj = Class.forName(classPath).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return obj;
    }


    private static Map<String,Object> beansMap = new HashMap<>();
    /**
     *  单例工厂
     *      第一次创建对象，后续都是获取第一次创建的对象。
     *
     *      1.声明变量，接受创建的对象。
     *      2.优先从map中获取，如果有，直接返回。如果没有，创建
     *
     *
     *
     *
     *
     *  @param beanName   需要创建的对象的名字
     *  @return   返回创建的对象，如果对象创建失败，返回null
     */
    public static Object getBean2(String beanName){

        Object obj = beansMap.get(beanName);
        if(obj==null){
            //第一次创建
            //1.读取配置
            ResourceBundle rb = ResourceBundle.getBundle("beans");
            String classPath = rb.getString(beanName);
            //2.反射机制创建对象
            try {
                obj = Class.forName(classPath).newInstance();
                //保存到map，方便下次直接获取
                beansMap.put(beanName,obj);
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }

        return obj;
    }



    public static void main(String[] args) {
        UserService userService = (UserService) getBean2("userService");
        UserService userService2 = (UserService) getBean2("userService");
        System.out.println(userService);
        System.out.println(userService2);
//        RoleService roleService = (RoleService)getBean("roleService");
//        System.out.println(roleService);
    }
}

2.1.4 单例工厂和多例工厂的区别

多例：
	1.什么时候用，什么时候创建。
	2.一旦创建成功，工厂想要再次操作这个对象，可不可以？  不可以的。
单例：
	1.可以第一次用的时候创建，也可以先全部创建好。
	2.一旦创建成功，工厂想要再次操作这个对象，可不可以？   可以，只要从map中获取即可。

2.2 spring的使用

2.2.1 spring的入门

步骤：
1.引入spring-context 依赖,spring的ioc核心依赖。
2.编译spring的配置xml
3.通过spring工厂获取对象

1.pom.xml引入依赖

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.6.RELEASE</version>
    </dependency>
</dependencies>

2.编写spring的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">

    <!-- bean definitions here -->

    <bean id="userService" class="com.it.service.impl.UserServiceImpl"></bean>

</beans>

3.通过spring的工厂获取对象

package com.it.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {
    public static void main(String[] args) {

        //1.创建spring的工厂
        ApplicationContext ac = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        //2.通过spring的工厂获取对象
        Object userService = ac.getBean("userService");
        System.out.println(userService);

    }
}

2.2.2 spring的工厂类（了解）

BeanFactory: spring工厂的顶层接口
applicationContext: BeanFactory的子接口
		FileSystemXmlApplicationContext: 基于绝对路径的xml的工厂
		ClassPathXmlApplicationContext: 基于相对路径的xml的工厂

2者的区别就是：创建（单例）对象的时间不一样
BeanFactory:    什么时候使用，什么时候创建
applicationContext:   工厂初始化时，全部创建成功

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

    <!-- bean definitions here -->

    <!--
        bean标签：  创建对象，将对象装配到spring容器（泛指spring工厂类）。

            id: 对象的唯一标识
            class:实现类的路径，底层就是通过反射机制创建对象的。

            init-method:  对象创建时，要调用的初始化方法
            destroy-method:  对象销毁时，要调用的销毁方法

            scope:
                singleton: 单例(默认)
                prototype: 多例

            对象的生命周期：


                applicationContext: 工厂初始化时，对象就创建完毕。（单例情况下）
                单例：
                    工厂初始化时创建对象。
                    只要工厂存在，对象就存在。
                    工厂销毁，对象销毁。
                多例：
                    什么时候用，什么时候创建。
                    工厂存在，对象存在。
                    工厂销毁，对象不销毁。对象只能等待垃圾回收机制回收。

    -->

    <bean id="userService" scope="prototype" init-method="init" destroy-method="destroy" class="com.it.service.impl.UserServiceImpl"></bean>

</beans>

test:

package com.it.test;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

public class SpringTest {
    public static void main(String[] args) {

        System.out.println("**************工厂初始化start*********************");
        //1.创建spring的工厂
        //ApplicationContext ac = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
//        Resource resource = new ClassPathResource("applicationContext.xml");
//        BeanFactory ac = new XmlBeanFactory(resource);

        System.out.println("**************工厂初始化end*********************");
        //2.通过spring的工厂获取对象
        Object userService = ac.getBean("userService");
        Object userService2 = ac.getBean("userService");
        System.out.println(userService);
        System.out.println(userService2);

        //销毁工厂
        System.out.println("*************销毁工厂*********************8");
        ac.close();

    }
}

2.2.4 spring创建对象的3种方式

1.默认无参构造
2.工厂类的静态方法
3.工厂类的动态方法

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创建对象的4种方式
            1.默认无参构造
            2.工厂类的静态方法
            3.工厂类的动态方法


            4.BeanFactory接口方式，ssm整合再去介绍
    -->
    <!-- 默认无参构造方式-->
    <bean id="userService" class="com.it.service.impl.UserServiceImpl"></bean>


    <!-- 工厂类的静态方式 -->
    <bean id="userService2" class="com.it.utils.BeanFactory" factory-method="getUserService"></bean>


    <!-- 工厂类的动态方法-->
    <bean id="factoryBean2" class="com.it.utils.BeanFactory2"></bean>
    <bean id="userService3" factory-bean="factoryBean2" factory-method="getUserService" ></bean>

</beans>

UserServiceImpl

package com.it.service.impl;

import com.it.service.UserService;

public class UserServiceImpl implements UserService {



    public UserServiceImpl() {
        System.out.println("UserServiceImpl的无参构造被调用了");
    }

}

BeanFactory工厂类的静态方法

package com.it.utils;

import com.it.service.UserService;
import com.it.service.impl.UserServiceImpl;

public class BeanFactory {

    public static UserService getUserService(){
        System.out.println("工厂类的静态方法");
        return new UserServiceImpl();
    }
}

BeansFactroy2工厂类的动态方法

package com.it.utils;

import com.it.service.UserService;
import com.it.service.impl.UserServiceImpl;

public class BeanFactory2 {

    public  UserService getUserService(){
        System.out.println("工厂类的静态方法");
        return new UserServiceImpl();
    }
}

2.2.5 spring的DI

Dependency Injection (依赖注入)：spring创建对象的时候，给对象的属性赋值，就是依赖注入。

2.2.5.1 有参构造

UserDao

package com.it.dao;

public interface UserDao {

    public void findUserByUser();
}

UserDaoImpl

package com.it.dao.impl;

import com.it.dao.UserDao;

public class UserDaoImpl implements UserDao {
    @Override
    public void findUserByUser() {
        System.out.println("查询用户信息");
    }
}

UserService

package com.it.service;

public interface UserService {

    public void login();
}

UserServiceImpl

package com.it.service.impl;

import com.it.dao.UserDao;
import com.it.dao.impl.UserDaoImpl;
import com.it.service.UserService;

public class UserServiceImpl implements UserService {



    private String username;
    private Integer age;
    private String game;
    private UserDao userDao;

    public UserServiceImpl(String username, Integer age, String game, UserDao userDao) {
        this.username = username;
        this.age = age;
        this.game = game;
        this.userDao = userDao;
    }

    public UserServiceImpl() {
    }

    @Override
    public void login() {
        userDao.findUserByUser();
    }
}

Test

package com.it.test;

import com.it.service.UserService;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

public class SpringTest {
    //这是一个servlet
    public static void main(String[] args) {

        //调用service
        ApplicationContext ac = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        UserService userService = (UserService)ac.getBean("userService3");
        userService.login();

    }
}

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

    <!-- 有参构造方式-->
    <bean id="userService" class="com.it.service.impl.UserServiceImpl">
        <!--
            给哪个属性赋什么值

            确定属性
                name: 通过属性名确定属性
                type: 通过属性的类型确定属性
                index: 通过索引来确定属性

            赋值：
                value：基本类型的赋值
                ref: 引用型类型的赋值
        -->
        <constructor-arg name="age" value="23"  ></constructor-arg>
        <constructor-arg name="game" value="LOL"></constructor-arg>
        <constructor-arg name="username" value="张三"></constructor-arg>
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>
    </bean>

    <!-- 有参构造方式-->
    <bean id="userService2" class="com.it.service.impl.UserServiceImpl">

        <constructor-arg index="1" value="23"  ></constructor-arg>
        <constructor-arg index="2" value="LOL"></constructor-arg>
        <constructor-arg index="0" value="张四"></constructor-arg>
        <constructor-arg index="3" ref="userDao"></constructor-arg>
    </bean>

    <!-- 有参构造方式-->
    <bean id="userService3" class="com.it.service.impl.UserServiceImpl">

        <constructor-arg type="java.lang.Integer" value="23"  ></constructor-arg>
        <constructor-arg type="java.lang.String" value="王五"></constructor-arg>
        <constructor-arg type="java.lang.String" value="LOL"></constructor-arg>
        <constructor-arg type="com.it.dao.UserDao" ref="userDao"></constructor-arg>
    </bean>

    <bean id="userDao" class="com.it.dao.impl.UserDaoImpl"></bean>
</beans>

2.2.5.2 set方法

UserServiceImpl

package com.it.service.impl;

import com.it.dao.UserDao;
import com.it.dao.impl.UserDaoImpl;
import com.it.service.UserService;

public class UserServiceImpl implements UserService {



    private String username;
    private Integer age;
    private String game;
    private UserDao userDao;

    public UserServiceImpl(String username, Integer age, String game, UserDao userDao) {
        this.username = username;
        this.age = age;
        this.game = game;
        this.userDao = userDao;
    }


    public void setUsername(String username) {
        this.username = username;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public void setGame(String game) {
        this.game = game;
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }



    public UserServiceImpl() {
    }

    @Override
    public void login() {
        userDao.findUserByUser();
    }
}

applicationContext.xml

<!-- 属性的set方法 -->
<bean id="userService4" class="com.it.service.impl.UserServiceImpl">

    <!--
        name:用来确定属性的。
            name属性的值是set的方法名去掉set后的驼峰命名名字。
        value：基本类型的属性赋值
        ref:引用型类型的属性赋值
    -->
    <property name="username" value="赵六"></property>
    <property name="age" value="25"></property>
    <property name="game" value="王者荣耀"></property>
    <property name="userDao" ref="userDao"></property>
</bean>

2.2.5.3 依赖注入的简写方式（了解）

c名称空间（原理采用的是有参构造）

xmlns:c="http://www.springframework.org/schema/c"

p名称空间 (原理采用的是set方法)


xmlns:p="http://www.springframework.org/schema/p"

<!-- c名称空间-->
<bean id="userService5" class="com.it.service.impl.UserServiceImpl"
      c:age="18" c:game="王者荣耀" c:username="c罗" c:userDao-ref="userDao"></bean>

<!-- p名称空间-->
<bean id="userService6" class="com.it.service.impl.UserServiceImpl"
        p:age="18" p:username="柳岩" p:game="足球" p:userDao-ref="userDao"></bean>

2.2.5.4 复杂类型的注入

UserServiceImpl2

package com.it.service.impl;

import com.it.dao.UserDao;
import com.it.service.UserService;

import java.util.HashMap;
import java.util.List;
import java.util.Set;
import java.util.Map;

public class UserServiceImpl2 implements UserService {


    private String[] gameNames;
    private List<String> dogType;
    private Set<String> catType;
    private Map<String,String> map;


    public void setGameNames(String[] gameNames) {
        this.gameNames = gameNames;
    }

    public void setDogType(List<String> dogType) {
        this.dogType = dogType;
    }

    public void setCatType(Set<String> catType) {
        this.catType = catType;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    @Override
    public void login(){
    }
}

applicationContext.xml

<!--复杂类型的注入-->
<bean id="userService7" class="com.it.service.impl.UserServiceImpl2">
    <property name="gameNames">
        <array>
            <value>LOL</value>
            <value>打豆豆</value>
            <value>王者荣耀</value>
        </array>
    </property>
    <property name="dogType">
        <list>
            <value>泰日天</value>
            <value>二哈</value>
            <value>中华田园犬</value>
        </list>
    </property>
    <property name="catType">
        <set>
            <value>蓝猫</value>
            <value>橘猫</value>
            <value>加菲猫</value>
        </set>
    </property>
    <property name="map">
       <map>
           <entry value="bb" key="aa"></entry>
       </map>
    </property>

</bean>

3.总结

理解了解
1.工厂模式，理解，关键单例工厂和多例工厂的区别，就是在于单例工厂有一个map集合保存bean对象，
   多例没有，创建之后直接返回。
2.spring的工厂类
	单例模式下，创建对象的时间节点不一样。
	BeanFactory: 顶层接口，什么时候用，什么时候创建对象。
	ApplicationContext:BeanFactory的子接口。工厂初始化时创建

掌握的
1.spring的2大核心思想
	ioc: 控制反转，对象的创建由我们自己new，换成spring工厂创建
	aop: 面向切面的编程，底层就是动态代理，在不修改源码的情况下增强功能
2.spring的入门步骤
	a.引入spring-context依赖
	b.编写spring的配置applicationContext.xml
	c.通过spring工厂获取对象  ApplicationContext(ClasspathXmlApplicationContext)
3.spring的bean标签
	id:唯一标识
	class:实现类的路径
	init-method:初始化要调用的方法
	destroy-method:销毁时要调用的方法
	scope:
		singleton:单例
		prototype:多例
4.spring创建对象的3种方式
	1.默认无参构造
	2.工厂类的静态方法
	3.工厂类的动态方法
5.spring的依赖注入
	spring在创建对象的时候，给对象的属性赋值，叫做依赖注入。
	1.有参构造
		<constructor-arg>
         确定属性的
         	name:属性名确定属性
         	index:索引确定属性
         	type:类型确定属性
         确定值的
         	value：基本类型赋值
         	ref:引用类型的赋值
     2.set方式
    	 <property>
     	 name:用来确定属性的。
                name属性的值是set的方法名去掉set后的驼峰命名名字。
          value：基本类型的属性赋值
          ref:引用型类型的属性赋值

例工厂的区别，就是在于单例工厂有一个map集合保存bean对象，
多例没有，创建之后直接返回。
2.spring的工厂类
单例模式下，创建对象的时间节点不一样。
BeanFactory: 顶层接口，什么时候用，什么时候创建对象。
ApplicationContext:BeanFactory的子接口。工厂初始化时创建

掌握的
1.spring的2大核心思想
ioc: 控制反转，对象的创建由我们自己new，换成spring工厂创建
aop: 面向切面的编程，底层就是动态代理，在不修改源码的情况下增强功能
2.spring的入门步骤
a.引入spring-context依赖
b.编写spring的配置applicationContext.xml
c.通过spring工厂获取对象 ApplicationContext(ClasspathXmlApplicationContext)
3.spring的bean标签
id:唯一标识
class:实现类的路径
init-method:初始化要调用的方法
destroy-method:销毁时要调用的方法
scope:
singleton:单例
prototype:多例
4.spring创建对象的3种方式
1.默认无参构造
2.工厂类的静态方法
3.工厂类的动态方法
5.spring的依赖注入
spring在创建对象的时候，给对象的属性赋值，叫做依赖注入。
1.有参构造

确定属性的
name:属性名确定属性
index:索引确定属性
type:类型确定属性
确定值的
value：基本类型赋值
ref:引用类型的赋值
2.set方式

name:用来确定属性的。
name属性的值是set的方法名去掉set后的驼峰命名名字。
value：基本类型的属性赋值
ref:引用型类型的属性赋值