Spring（一）——Spring的概念、搭建Spring环境、Spring容器ApplicationContext、Spring Bean的五个作用域_applicationcontext的作用范围

1.Spring的概念及作用

低耦合、高内聚：高内聚——协作能力非常强，
框架适用于大项目

什么是Spring？

（1）Spring是一个开源的的轻量级的应用开发框架，其目的是用来简化企业级应用程序开发，减少代码之间的侵入性。
（2）Spring提供的IOC和AOP应用，可以将组件的耦合度将至最低，即我们常说的解耦，这样能便于日后系统的升级和维护。
（3）Spring为系统提供了一个整体的解决方案，开发者除了可以利用它本身提供的功能外，还可以与第三方 的框架和技术整合应用，可以自由的选择采用哪种技术进行开发。

• 使用Spring的目的：Spring 的本质是管理软件中的对象，即如何创建对象和维护对象之间的关系。

• Spring管理对象，也就是管理JavaBean，核心容器的主要组件为BeanFactory。

• Spring Core：核心库

• Spring AOP——面向切面编程：登录拦截器

• Sring ORM：映射

任何Java类和JavaBean都会被当做bean处理。
Spring容器主要有BeanFactory和ApplicationContext两种类型

BeanFacotry是Spring中比较原始的Factory，ApplicationContext继承自BeanFactory接口，拥有更多的企业级方法，原始的BeanFactory无法支持Spring的许多插件，如AOP功能、Web应用等， 所以在实际应用中推荐使用ApplicationContext，实例化ApplicationContext有两种方式（两种方式下都需要有applicationContext.xml配置文件）

2.搭建Spring环境（不用maven）

新建lib文件夹——》添加jar包——》鼠标右键Add as Liberary

File——》Project Structure——》Modules——》Dependencies——》lib Scope改为compile
web运行——provided，main运行——compile
Compile 既会参加编译，又会参加运行，而provided只会参加编译
导入的jar包用默认的compile就行。

3.Spring容器ApplicationContext

3.1 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-4.3.xsd

">
    <!--xsd文件：xml结构定义-->
    <!--配置bean -->
    <bean id="user" name="user1,user2,user3" class="cn.goktech.entity.User" />
</beans>
1
2
3
4
5
6
7
8
9
10
11
12
13

xmlns="http://www.springframework.org/schema/beans"  //命名空间
1

3.2通过ApplicationContext获取bean

1.通过id
2.通过name
3.通过 类型class XXX.class

public class Test {
    public static void main(String[] args) {
       //ClassPathXmlApplicationContext 默认路径是从src开始，而FileSystemXmlApplicationContext默认路径是从项目下开始
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        ApplicationContext context1 = new FileSystemXmlApplicationContext("src/applicationContext.xml");
        //1.通过id获取bean
        User user = (User)context.getBean("user");
        user.setName("Alice");
        user.setId(1001);
        System.out.println(user);
        //2.通过name获取bean
        User user1 = (User)context.getBean("user1");
        user.setName("Bob");
        user.setId(1002);
        System.out.println(user1);
        //3.通过类型获取bean
        User user2 = (User)context.getBean(User.class);
        user.setName("Clover");
        user.setId(1003);
        System.out.println(user2);
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

实例化ApplicationContext的两种方式：

//ClassPathXmlApplicationContext 默认路径是从src开始，而FileSystemXmlApplicationContext默认路径是从项目下开始
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        ApplicationContext context1 = new FileSystemXmlApplicationContext("src/applicationContext.xml");
1
2
3

也可以是绝对路径：
ClassPathXmlApplicationContext ： 需要加file前缀

ApplicationContext  applicationContext  = new  ClassPathXmlApplicationContext("file:D:/FirstSpringPJ/src/ac.xml");
1

FileSystemXmlApplicationContext可以省略file前缀，直接写磁盘路径

ApplicationContext ac=new FileSystemXmlApplicationContext  ("D:\FirstSpring_Project\src\ac.xml");
1

当需要加载多个applicationContext.xml文件时可以是数组：

ApplicationContext ac = new ClassPathXmlApplicationContext(new  	String[]{"applicationContext.xml"，"ac1.xml"，”ac2.xml”});
1

4.Bean的实例化

（1）构造器实例化（默认）

<bean id="user" name="user1,user2,user3" class="cn.goktech.entity.User"></bean>
1

• 指定好标识符id或者name以及类型class以后，Spring容器会通过无参构造器来实例化该类，所以使用这个方式来实例化Bean要求要实例化的类中一定要求无参构造器
• id 或name属性用于指定该Bean的名称，以便从Spring中查找该Bean class 用来指定该Bean的类型，即我们要实例化哪个类，写全类名。
  （2）静态工厂实例化

<!--静态工厂实例化,指定静态方法 -->
<bean id="userFactory" class="cn.goktech.factory.UserFactory" factory-method="getInstance" />
1
2

上面的静态工厂实例化没有指定name，通过类型获取bean

//3.通过类型获取bean
User user2 = (User)context1.getBean(User.class);
user2.setName("Clover");
user2.setId(1003);
System.out.println(user2);
1
2
3
4
5

注意需要指定静态方法：

public static User getInstance(){
    System.out.println("静态实例化工厂");
    return new User();
}
1
2
3
4

（3）实例化工厂（既要配置bean，也要指定工厂）

<!--工厂实例化,指定bean的工厂 -->
<bean id="userFactory" class="cn.goktech.factory.UserFactory"  />
<bean id="user" class="cn.goktech.entity.User" factory-bean="userFactory" factory-method="createUser" />
1
2
3

5.Spring Bean 的五个作用域

scope：singleton单例模式、prototype原型模式、request、session、globalsession
（1）singleton单例模式（默认）：在整个Spring IoC容器中，使用singleton定义的Bean将只有一个实例。

ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
//1.通过id获取bean
User user = (User)context.getBean("user");
user.setName("Alice");
user.setId(1001);
System.out.println(user);
//2.通过name获取bean
User user1 = (User)context.getBean("user1");
//user.setName("Bob");
//user.setId(1002);
System.out.println(user1);
1
2
3
4
5
6
7
8
9
10
11

输出结果：

• 例如上面的代码，看起来创建了两次，实际使用的是同一个User。
• 在全局之中只有一个对象。
• 单例模式的好处：全局只会有一个实例

（2）prototype原型模式：每次通过容器的getBean方法获取prototype定义的Bean时，都将产生一个新的Bean实例。

每次都会new一次，每次向Spring要一个对象的时候，都会给一个全新的对象

<bean id="user" name="user1,user2,user3" class="cn.goktech.entity.User" scope="prototype"/>
1

3）request：对于每次HTTP请求，使用request定义的Bean都将产生一个新实例，即每次HTTP请求将会产生不同的Bean实例。只有在Web应用中使用Spring时，该作用域才有效。
（4）session：对于每次HTTP Session，将会产生不同的Bean实例。只有在Web应用中使用Spring时，该作用域才有效。
（5）globalsession：每个全局的HTTP Session，使用session定义的Bean都将产生一个新实例。一般用于Porlet应用环境 , 分布式系统存在全局session概念。如果不是porlet环境，globalSession 等同于Session 。

如果不指定Bean的作用域，Spring默认使用singleton作用域。

6.生命周期相关

初始化时要调用的方法
销毁时要调用的方法
User类中

//初始化方法
 public void init(){
     System.out.println("User实例创建成功");
}
//销毁方法
public void destroy(){
    System.out.println("User实例销毁成功");
}
1
2
3
4
5
6
7
8

注意：方法名init（）和destroy（）可以随意命名，不影响
生命周期相关：init-method，destroy-method

<bean id="user" name="user1,user2,user3" class="cn.goktech.entity.User"  init-method="init" destroy-method="destroy"/>
1

7.延迟实例化与提前实例化（默认是提前实例化）

默认情况下在ApplicationContext创建时会创建所有的singleton对象

ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
ApplicationContext context1 = new FileSystemXmlApplicationContext("src/applicationContext.xml");
//1.通过id获取bean
System.out.println("使用User对象");
User user = (User)context.getBean("user");
1
2
3
4
5

打印输出中，“无参构造调用”在“使用User对象”前，说明在ApplicationContext创建时会创建User对象

延迟实例化：lazy-init=“true” ，调用时创建对象

<bean id="user" name="user1,user2,user3" class="cn.goktech.entity.User"  init-method="init" destroy-method="destroy" lazy-init="true" />
1

打印输出中，“使用User对象”在“无参构造调用”前

若想要所有bean延迟实例化，可在bean标签中加上default-lazy-init=“true”

如果不延迟实例化，启动会慢一点。
虽然启动时会花费一些时间，但带来两个好处：
1、对Bean提前实例化操作会及早发现一些潜在的配置问题；
2、Bean以缓存的方式保存，当运行期使用到该Bean的时候无需再实例化，加快运行的效率

8.Spring IOC及DI（依赖注入）的使用

Spring IOC
IOC——Inversion of Control，即控制反转

它不是一种技术，而是一种设计思想，即java程序中获取对象的方式发生反转，由最初的new方式创建，转变成由第三方框架创建、注入。
1

DI——Dependency Injection，译为依赖注入。
IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象，这一点就是通过DI来实现的，即DI是实现IOC的主要技术途径。

1.setter注入：<property name="属性名" value="属性值" ref="注入bean的id" />
1

创建A类

public class A {
    public A(){
        System.out.println("A类调用成功");
    }
    public void af(){
        System.out.println("A类方法调用成功");
    }
}
1
2
3
4
5
6
7
8

创建B类

public class B {
    private int id;
    private A a;

    public B(){
        System.out.println("B类构造调用");
    }
    public B(int id, A a) {
        this.id = id;
        this.a = a;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public A getA() {
        return a;
    }

    public void setA(A a) {
        this.a = a;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

（1）setter注入
applicationContext.xml

<bean id="a" class="cn.goktech.entity.A" />
<!--依赖注入（给定参数值）：
     1.setter注入：<property name="属性名" value="属性值" ref="注入bean的id" />
 -->
 <bean id="b" class="cn.goktech.entity.B">
     <property name="id" value="1001"/><!--为了防止默认初始化，为了防止id=0,a=null，给定了value和ref,给定参数值 -->
     <property name="a" ref="a"/>
 </bean>
1
2
3
4
5
6
7
8

TestDI

public class TestDI {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        B b1 = context.getBean(B.class);
    }
}
1
2
3
4
5
6

运行结果：

如果注入成功，那么在TestDI中b1可以调用A类中的方法af()

public class TestDI {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        B b1 = context.getBean(B.class);
        b1.getA().af();
    }
}
1
2
3
4
5
6
7

运行结果为：

说明注入成功

（2）构造器注入

<bean id="a" class="cn.goktech.entity.A" />
   <!--依赖注入（给定参数值）：  
        2.构造器注入：<constructor-arg index="参数下标" value="属性值" ref="注入bean的id " />必须有该构造器
    -->
    <bean id="b" class="cn.goktech.entity.B">
        <constructor-arg index="0" value="1001"/>
        <constructor-arg index="1" ref="a"/>
    </bean>
1
2
3
4
5
6
7
8

运行结果

ref 一个类中注入了其他对象

还有一种写法：

<bean id="a" class="cn.goktech.entity.A" />
   <!--依赖注入（给定参数值）：  
        2.构造器注入：<constructor-arg index="参数下标" value="属性值" ref="注入bean的id " />必须有该构造器
    -->
    <bean id="b" class="cn.goktech.entity.B">
        <constructor-arg>
            <value>1001</value>
        </constructor-arg>
        <constructor-arg index="1" ref="a"/>
    </bean>
1
2
3
4
5
6
7
8
9
10