[Java知识库]Spring实战学习01----------之认识Bean

Spring概念

简介

Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核。

提供了展现层 SpringMVC和持久层 Spring JDBCTemplate以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架

发展历程

Rod Johnson （ Spring 之父）

2017 年
9 月份发布了 Spring 的最新版本 Spring5.0
通用版（GA）

优势

1、方便解耦，简化开发

? 通过Sping提供的IoC容器，可以将对象间的依赖关系交由Sping进行控制，避免编码所造成的过度耦合

2、AOP 编程的支持

? 通过Spring的AOP功能，方便进行面向切片编程，许多不容易传统OOP实现的功能可以通过AOP轻松实现

3、声明式事务的支持

可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明方式灵活的进行事务管理，提高开发效率和质量

4、方便程序的测试

集成Junit进行程序测试

5、方便集成各种优秀框架

Spring对各种优秀框架（Struts,Hibemate、Hessian、Quartz等）的支持

6、降低了JavaEE API的使用难度

Spring对javaEE API（如JDBC、JavaMail、远程调用）进行了薄薄的封装层，是这些API的使用难度大为降低。

Spring的体系结构

Spring开发图示

Spring开发步骤

1、导入Spring开发的基本包坐标

2、编写Dao接口和实现类

3、创建Spring核心配置文件

4、创建Spring配置文件中配置UserDaoImpl

5、使用Spring的API获得Bean实例

Spring快速入门

1、导入Spring开发的基本包坐标

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

2、编写Dao接口和实现类

接口

public interface UserDao {
    public void save();
}

实现类

public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("do 		save......");
    }
}

3、创建Spring核心配置文件

4、创建Spring配置文件中配置UserDaoImpl

``

<?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="userDao" class="Z.S.dao.impl.UserDaoImpl"> </bean> 


</beans>

5、使用Spring的API获得Bean实例

public class UserDaoDemo {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicetionContext.xml");
        UserDao userDao = (UserDao) app.getBean("userDao");
        userDao.save();

    }

测试结果：

Spring配置文件 -Bean

Bean标签的基本配置

用于配置对象交由Spring来创建

默认情况下他调用的是类中的无参构造函数，如果没有无参构造则不能创建成功。

基本属性：

id:Bean实例在Spring容器中的唯一标识

class:Bean的全限定名称

什么是Bean?

在 Spring 中，构成应用程序主干并由Spring IoC容器管理的对象称为bean。bean是一个由Spring IoC容器实例化、组装和管理的对象。

我们总结如下：
1.bean是对象，一个或者多个不限定
2.bean由Spring中一个叫IoC的东西管理
3.我们的应用程序由一个个bean构成

关于Bean的规范
1.所有属性为private
2.提供默认构造方法
3.提供getter和setter
4.实现serializable接口

Bean标签的范围取值

scope:值对象的作用范围，取值如下

1??测试属性为singleton时是不是创建一个单例对象

1、修改属性值

<bean id="userDao" class="Z.S.dao.impl.UserDaoImpl" scope="singleton"></bean>

2、编写测试类，定义不同名的两个对象并比较地址值，如果返回true则说明是单例

``

public void test1(){
    ApplicationContext app = new ClassPathXmlApplicationContext("applicetionContext.xml");
    UserDao userDao1 = (UserDao) app.getBean("userDao");
    UserDao userDao2 = (UserDao) app.getBean("userDao");
    System.out.println(userDao1.equals(userDao2));
}

打印结果

结论：是单例

2??测试属性为prototype时是不是创建多例对象

1、修改属性值

<bean id="userDao" class="Z.S.dao.impl.UserDaoImpl" scope="prototype"></bean>

2、编写测试类，定义不同名的两个对象并比较地址值，如果返回false则说明是多例（容器中存在多个对象），否则则是单例

``

@Test
public void test2(){
    ApplicationContext app = new ClassPathXmlApplicationContext("applicetionContext.xml");
    UserDao userDao1 = (UserDao) app.getBean("userDao");
    UserDao userDao2 = (UserDao) app.getBean("userDao");
    System.out.println(userDao1.equals(userDao2));
}

打印结果:

结论：是多例

由于其他三种需要在WEB环境下进行演示，这里就不一一演示了

测试?两个属性的对象创建时期

1??singleton

由于Spring创建对象是通过无参构造进行创建对象，因此我们可以在实现类中提供无参构造器，并打印一句话，如果创建对象时成功输出该语句，则说明无参构造方法被调用了，同时也说明该对象被创建了一次

1、设置参数

<bean id="userDao" class="Z.S.dao.impl.UserDaoImpl" scope="singleton"></bean>

2、在实现类中提供无参构造

``

/**
 * @author 朱霸霸
 * @date 2022/5/31 19:15
 */
public class UserDaoImpl implements UserDao {

    public UserDaoImpl() {
        System.out.println("UserDaoImpl创建。。。");
    }

    @Override
    public void save() {
        System.out.println("do save......");
    }
}

3、编写测试类

``

@Test
public void test3(){
    ApplicationContext app = new ClassPathXmlApplicationContext("applicetionContext.xml");
    UserDao userDao = (UserDao) app.getBean("userDao");
    userDao.save();

}

启动debug测试：

打印结果：

结论：创建容器并配置文件一旦被加载，UserDao对象则被创建

2??

1、设置参数

<bean id="userDao" class="Z.S.dao.impl.UserDaoImpl" scope="prototype"></bean>

2、在实现类中提供无参构造

``

public class UserDaoImpl implements UserDao {

    public UserDaoImpl() {
        System.out.println("UserDaoImpl创建。。。");
    }

    @Override
    public void save() {
        System.out.println("do save......");
    }
}

3、编写测试类

``

    public void test3(){
        ApplicationContext app = new ClassPathXmlApplicationContext("applicetionContext.xml");
        UserDao userDao1 = (UserDao) app.getBean("userDao");
        UserDao userDao2 = (UserDao) app.getBean("userDao");

        System.out.println(userDao1);
        System.out.println(userDao2);

    }


}

启动debug测试：

可以看出，参数为prototype时，是在getBean时创建对象的

总结：

1??当scope的取值为singleton时

? Bean的实例化个数：1个

? Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例

? Bean的生命周期：

• 对象创建：当应用加载，创建容器时，对象就被创建了

• 对象运行：只要容器在，对象一直活着

• 对象销毁：当应用卸载，销毁容器时，对象就被销毁了

2??当scope的取值为prototype时

? Bean的实例化个数：多个

? Bean的实例化时机：当调用getBean()方法时实例化Bean

• 对象创建：当使用对象时，创建新的对象实例

• 对象运行：只要对象在使用中，就一直活着

• 对象销毁：当对象长时间不用时，被 Java 的垃圾回收器回收了

Bean生命周期配置

• init-method:指定类中的初始化方法名称
• destory-method:指定类中销毁方法名称

测试：

在实现类中创建两个方法，一个是代表对象创建完毕的初始化方法，一个代表这个对象销毁之前的销毁方法

``

public class UserDaoImpl implements UserDao {

    public UserDaoImpl() {
        System.out.println("UserDaoImpl创建。。。");
    }

    public void init(){
        System.out.println("初始化方法。。。");
    }


    public void destroy(){
        System.out.println("销毁方法方法。。。");
    }

    @Override
    public void save() {
        System.out.println("do save......");
    }
}

没有在配置文件中指明方法时，init方法和destroy方法是不会被调用的

在配置文件中指明方法

<bean id="userDao" class="Z.S.dao.impl.UserDaoImpl" init-method="init" destroy-method="destroy"></bean>

测试类：

    @Test
    public void test3(){
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicetionContext.xml");
        UserDao userDao1 = (UserDao) app.getBean("userDao");
        System.out.println(userDao1);
        app.close();
    }
}

打印结果：

因为是单元测试，并没有在服务器内执行，还没来得及打印销毁方法，方法就执行完毕了。所以我们需要让容器手动关闭，容器在自动关闭前会执行一些方法，但 ApplicationContext没有close方法，所以这里使用ClassPathXmlApplicationContext 。

Bean实例化的三种方式

• 无参构造方法实例化（重点）
• 工厂静态方法实例化
• 工厂实例方法实例化

工厂静态方法实例化

1、创建静态工厂

public class staticFactory {
    public static UserDao getUserDao(){
        return new UserDaoImpl();
    }

}

2、在配置文件中说明，通知Spring是通过静态工厂创建

<bean id="userDao" class="Z.S.factory.staticFactory"  factory-method="getUserDao"></bean>

3、测试

    @Test
    public void test3(){
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicetionContext.xml");
        UserDao userDao1 = (UserDao) app.getBean("userDao");
        System.out.println(userDao1);
        //app.close();
    }
}

打印结果：

工厂实例方法实例化

1、此时该方法不再是静态，

public class DynamicFactory {
    public  UserDao getUserDao(){
        return new UserDaoImpl();
    }
}

2、在配置文件中说明，通知Spring是通过实例工厂创建（由于是非静态，所以需要先有工厂对象，才能调用方法）

<bean id="factory" class="Z.S.factory.DynamicFactory"></bean>
<bean id="userDao" factory-bean="factory" factory-method="getUserDao"></bean> 

3、测试

    public void test3(){
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicetionContext.xml");
        UserDao userDao1 = (UserDao) app.getBean("userDao");
        System.out.println(userDao1);
        //app.close();
    }
}

测试结果：

Spring配置文件-依赖注入

模拟web环境下的三层结构

1、创建业务层代码

public interface UserService {
    public void save();
}

//**********************
public class UserServiceImpl implements UserService {
    @Override
    public void save() {
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicetionContext.xml");
        UserDao userDao = (UserDao) app.getBean("userDao");
        userDao.save();
    }

3、模拟web（由于Spring没有获取到userService对象，这里需要我们进行手动创建）

public class UserController {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        userService.save();
    }
}

测试结果：

3.+：我们可以通过配置文件配置并获取userService对象

<bean id="userDao" class="Z.S.dao.impl.UserDaoImpl"></bean>

<bean id="userService" class="Z.S.service.impl.UserServiceImpl"></bean>

模拟web层

public class UserController {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService =(UserService) app.getBean("userService");
        userService.save();

    }
}

测试结果：

上面的代码是存在问题的

因为UserService和UserDao都在Spring容器中，而最终程序直接使用的是UserService,所以可以在Spring容器中，将UserDao设置到UserService内部

我们可以通过有参构造把数据注入到对象内部

依赖注入

依赖注入（Dependency Injection）：它是 Spring 框架核心 IOC 的具体实现。

在编写程序时，通过控制反转，把对象的创建交给了 Spring，但是代码中不可能出现没有依赖的情况。

IOC 解耦只是降低他们的依赖关系，但不会消除。例如：业务层仍会调用持久层的方法。

那这种业务层和持久层的依赖关系，在使用 Spring 之后，就让 Spring 来维护了。

简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取

Bean的依赖注入方式

• 构造方法
• set方法

①set方法

1、在UserServiceImpl内提供set方法

public class UserServiceImpl implements UserService {
   private UserDao userDao;

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

    @Override
    public void save() {
        userDao.save();
    }
}

2、在配置文件中进行配置，告诉Spring把UserDao注入给UserServiceImpl

<bean id="userDao" class="Z.S.dao.impl.UserDaoImpl"></bean>

<bean id="userService" class="Z.S.service.impl.UserServiceImpl">
    <property name="userDao" ref="userDao"></property>                              <!--name:是set方法后面的字符，并将第一个字母变成小写（set属性名字） ref:引用的对象-->
</bean>

测试：

public class UserController {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicetionContext.xml");
        UserService userService =(UserService) app.getBean("userService");
        userService.save();

    }
}

测试结果：

简便注入（P命名空间注入）：

②构造方法

1、在UserServiceImpl内提供构造器

public class UserServiceImpl implements UserService {
   private UserDao userDao;

    public UserServiceImpl(UserDao userDao) {
        this.userDao = userDao;
    }
    public UserServiceImpl(){}

    @Override
    public void save() {
        userDao.save();
    }
}

2、配置Spring容器调用有参构造时进行注入

<bean id="userService" class="Z.S.service.impl.UserServiceImpl">
    <constructor-arg name="userDao" ref="userDao"></constructor-arg>  <!--虽然name和ref的属性名字相同，但含义不同name为内部构造的参数名，ref为引用容器中的bean Id-->
</bean>

3、测试

public class UserController {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicetionContext.xml");
        UserService userService =(UserService) app.getBean("userService");
        userService.save();

    }
}

测试结果：

依赖注入的数据类型

上面的操作，都是注入的引用Bean，处了对象的引用可以注入，普通数据类型，集合等都可以在容器中进行注入。

注入数据的三种数据类型

• 普通数据类型

• 引用数据类型

• 集合数据类型

其中引用数据类型，此处就不再赘述了，之前的操作都是对UserDao对象的引用进行注入的，下面将以set方法注入为例，演示普通数据类型和集合数据类型的注入。

测试普通数据类型（set方法）

1、在UserDaoImpl中提供set方法

public class UserDaoImpl implements UserDao {
    private String username;
    private int age;

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

    public void setAge(int age) {
        this.age = age;
    }
    
        @Override
    public void save() {
        System.out.println(username+"======"+age);
        System.out.println("do save......");
    }
}

2、在配置文件中进行配置

<bean id="userDao" class="Z.S.dao.impl.UserDaoImpl">
    <property name="username" value="达瓦里氏" />
    <property name="age" value="18"/>
</bean>

测试：

public class UserController {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicetionContext.xml");
        UserService userService =(UserService) app.getBean("userService");
        userService.save();

    }
}

测试结果：

测试集合数据类型（set方法）

1、在UserDaoImpl中提供集合属性并提供set方法

public class UserDaoImpl implements UserDao {
    private String username;
    private int age;
    private List<String> strList;
    private Map<String, User> userMap;
    private Properties properties;

    public void setStrList(List<String> strList) {
        this.strList = strList;
    }

    public void setUserMap(Map<String, User> userMap) {
        this.userMap = userMap;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

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

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


    @Override
    public void save() {
        System.out.println(username+"======"+age);
        System.out.println("strList："+strList);
        System.out.println("userMap:"+userMap);
        System.out.println("properties:"+properties);
        System.out.println("do save......");
    }
}

2、在配置文件中进行配置

<!--<bean id="factory" class="Z.S.factory.DynamicFactory"></bean>-->
<!--<bean id="userDao" factory-bean="factory" factory-method="getUserDao"></bean>-->
    <bean id="userDao" class="Z.S.dao.impl.UserDaoImpl">
        <!--注入普通数据类型-->
        <property name="age" value="18"/>
     
        <!--注入集合数据类型-->
        <property name="strList"  >
            <list>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value> <!--如果该处list的值不是字符串，则可以使用ref进行引用,被引用对象必须存在容器中-->
            </list>
        </property>


        <property name="userMap">
            <map>
              <entry key="u1" value-ref="user1"></entry>
                <entry key="u2" value-ref="user2"></entry>
            </map>
        </property>

        <property name="properties">
            <props>
                <prop key="p1">pppp1</prop>
                <prop key="p2">pppp2</prop>
                <prop key="p3">pppp3</prop>
            </props>
        </property>

    </bean>

    <!--注入user类-->
    <bean id="user1" class="Z.S.domain.User">
        <property name="name" value="tom"/>
        <property name="address" value="江苏省"/>
    </bean>
    <bean id="user2" class="Z.S.domain.User">
        <property name="name" value="lisa"/>
        <property name="address" value="新疆省"/>
    </bean>

<!--    <bean id="userService" class="Z.S.service.impl.UserServiceImpl">-->
<!--        <property name="userDao" ref="userDao"></property>                              &lt;!&ndash;name:是set方法后面的字符，并将第一个字母变成小写（set属性名字） ref:引用的对象&ndash;&gt;-->
<!--    </bean>-->
    <bean id="userService" class="Z.S.service.impl.UserServiceImpl">
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>  <!--虽然name和ref的属性名字相同，但含义不同name为内部构造的参数名，ref为引用容器中的bean Id-->
    </bean>
</beans>

测试类

public class UserController {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicetionContext.xml");
        UserService userService =(UserService) app.getBean("userService");
        userService.save();

    }
}

测试结果

引入其他配置文件（分模块开发）

实际开发中，Spring的配置内容非常多，这就导致Spring配置很繁杂且体积很大，所以，可以将部分配置拆解到其他配置文件中，而在Spring主配置文件通过import标签进行加载

可以根据层分，也可以根据功能去拆

<import resource="applicationContext-xxx.xml"/>

Spring的重点配置

Spring相关API

ApplicationContext的继承体系

三个实现类

getBean的方法

其中，当参数的数据类型是字符串时，表示根据Bean的id从容器中获得Bean实例，返回是Object，需要强转。

当参数的数据类型是Class类型时，表示根据类型从容器中匹配Bean实例，当容器中相同类型的Bean有多个时，则此方法会报错

ApplicationContext applicationContext = new 
            ClassPathXmlApplicationContext("applicationContext.xml");
  UserService userService1 = (UserService) applicationContext.getBean("userService");
  UserService userService2 = applicationContext.getBean(UserService.class);