Spring基础学习

Spring简介

Spring是分层的JavaSE/EE full-stack 轻量级开源框架，以IoC（Inverse of Control 控制反转）和AOP（Aspect Oriented Programming 面向切面编程）为内核，使用基本的JavaBean来实现程序功能。
在实际开发中，通常服务器端采用三层体系架构，分别为表示层(web)、业务逻辑层(service)、持久层(dao)， Spring对每一层都提供了技术支持。

Spring具有简单、可测试和松耦合的特点，从这个角度出发，Spring不仅可以用于服务器端开发，也可以应用于任何Java应用的开发中。

Spring几大核心功能
1.IoC/DI 控制反转/依赖注入
2. AOP 面向切面编程
3 声明式事务

上图是spring框架的运行框架
一：Test
Test：是Spring提供的测试功能

二：Core Container
Core Container是核心容器，也是Spring提供的最基本的条件
包含：
1.Beans：提供Spring负责创建类对象并管理对象的功能
2.Core：核心类
3.Context：上下文参数。获取外部资源或管理注解等
4.SpEL：是一种强大的表达式语言

三：其他模块
AOP模块 ：实现aop功能需要依赖。允许定义方法拦截器和切入点，将代码按照功能进行分离，以降低耦合性

Aspects模块 ： 切面 AOP 依赖的包

Instrumentation模块 ：提供了类工具的支持和类加载器的实现，可以在特定的应用服务器中使用

四：Data Access/INtegration(数据访问/集成)模块
JDBC模块：Spring 对 JDBC 封装后的代码。提供了一个JDBC的抽象层，大幅度地减少了在开发过程中对数据库操作的代码

ORM模块：封装了持久层框架的代码.例如 Hibernate

transactions模块：支持编程和声明式事务管理实现特殊接口类。对应 spring-tx.jar,声明式事务使用

JMS模块：指Java消息服务，包含的功能为生产和消息的信息

五：WEB模块
Web模块：提供了基本的web开发集成特性。如：使用的Servlet监听器的IOC容器初始化及web应用上下文

Servlet模块：包括Spring模型-视图-控制器(MVC)实现Web应用程序

Struts模块：包含支持类内的Spring应用程序，集成了经典的Struts Web层

Portlet模块：提供了在portlet环境中使用MVC实现，类似Web-Servlet模块的功能

Web模块:提供了需要 spring 完成 web 相关功能时的功能. 如:由 tomcat 加载 spring 配置文件时需要有 spring-web 包

.Spring 框架中重要概念
容器(Container): Spring 当作一个大容器.
在老版本中是BeanFactory 接口.在新版本中是ApplicationContext 接口,是 BeanFactory 子接 口.BeanFactory 的功能在 ApplicationContext 中都有. 7.

从 Spring3 开始把 Spring 框架的功能拆分成多个 jar. Spring2 及以前就一个 jar

环境搭建

导入jar包

基本的Spring需要导入的jar包
也就是Core模块的相关jar包

另外需要导入Commons-loggging的jar包，是一个第三方的依赖包，主要用于处理日志

配置文件

在src下建立applicationContext.xml(文件名称和路径可以自定义)
Spring的全局容器ApplicationContext。而applicationContext.xml 配置的信息最终存储到了 AppliationContext 容器中

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

使用Spring

建立一个实体类

package cn.com.pojo;

public class People {
    private int id;
    private String name;
    public int getId() {
        return id;
    }

    public void setId(int id) {
        System.out.println("setId");
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        System.out.println("setName");
        this.name = name;
    }

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

在Spring的配置文件中，配置实体类

<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="peo" class="cn.com.pojo.People">
        bean>
beans>

public class Text {
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        
        People people=context.getBean("peo", People.class);
        System.out.println(people);
    }
}

这样的好处，创建对象不用new而是交给Spring，通过 创建对象. Spring将创建好的对象放入容器类，而我们只需要从容器中去拿。这就是IOC(控制反转)

默认配置文件被加载时创建对象

IOC

IOC(Inversion of Control) 控制反转

IoC 完成的事情原先由程序员主动通过 new 实例化对象事情,
转交给 Spring 负责.
控制反转中控制指的是:控制类的对象
控制反转中反转指的是转交给 Spring 负责.

Spring的IOC容器

Spring提供了两种IOC容器，分别是BeanFactory和ApplicationContext

在老版本中是BeanFactory 接口.在新版本中是ApplicationContext 接口

1.BeanFactory
BeanFactory是基础类型的IOC容器，由org.springframework.beans.factory.BeanFactory接口定义

BeanFactory提供了完整的IOC服务支持。BeanFactory就是一个管理Bean的工厂，它主要负责初始化各种Bean，并调用它们的生命周期方法
创建BeanFactory 实例时，需要提供Spring所管理容器的详细配置信息，这些信息通常采用XML文件形式来管理

 BeanFactory factory=new XmlBeanFactory(new FileSystemResource("D:\\applicationContext.xml"));

可以看出XmlBeanFactory已经不推荐使用了

2.ApplicationContext
ApplicationContext 是BeanFactory的子接口，也称为应用上下文接口。全路径为org.springframework.context.ApplicationContext

ApplicationContext不仅提供BeanFactory所有的功能，还以一种面向框架的方式增强BeanFactory的功能。

ApplicationContext接口的实例创建有两种方法
1.ClassPathXmlApplicationContext:从类路径的XML文件载入上下文定义信息，把上下文定义文件当作类路径资源

ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");

2.FileSystemXml:从文件系统中指定路径的XML文件载入上下文定义信息

 ApplicationContext context= new FileSystemXmlApplicationContext("D:\\Spring\src\applicationContext.xml")

在老版本中是BeanFactory 接口.在新版本中是ApplicationContext 接口,

BeanFactory接口和ApplicationContext接口都是通过XML配置文件加载Bean的，相比之下，ApplicationContext提供更多的扩展功能
二者的主要区别是
BeanFactory采用的是延迟加载方案，只有在调用getBean()时才会实例化Bean.如果Bean的某一个属性没有注入，使用BeanFactory加载后，在第一次调用getBean()时会抛出异常。
而ApplicationContext则在初始化时就一次性创建所有bean,这样有利于所依赖的属性是否注入。

可以看出BeanFactory采用的是延迟加载方案，只有在调用getBean()时才会实例化Bean
ApplicationContext则在初始化时就一次性创建所有bean

Spring 创建对象的三种方式

1.通过构造方法创建

无参构造创建:默认情况.

<bean id="peo" class="cn.com.pojo.People">
 bean>

有参构造创建:需要配置

 public People(int id, String name) {     
     this.id = id;                        
     this.name = name;                    
 }                                        

建立有参构造方法

        <bean id="peo" class="cn.com.pojo.People">
            <constructor-arg name="id" value="1"/>
            <constructor-arg name="name" value="张三"/>
        bean>

使用有参构造方法需要添加标签
标签的 name属性是构造方法的参数名 value属性设立值

除了name属性和value属性还有
index属性 ：参数的索引从0开始
type属性：声明参数的类型 （需要区分关键字和封装类 如:int和Integer是不同的）

public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
       // BeanFactory factory=new XmlBeanFactory(new FileSystemResource("D:\\applicationContext.xml"));
        System.out.println("------------获取bean----------------");
        People people=context.getBean("peo", People.class);
        System.out.println(people);
    }
 }

2.实例工厂创建对象

工厂设计模式:帮助创建类对象.一个工厂可以生产多个对象

实例工厂:需要先创建工厂,才能生产对象

package cn.com.factory;

import cn.com.pojo.People;

public class PeopleFactory {
    public People newInstance(){
        return new People(11,"kryie");
    }
}

<bean id="factory" class="cn.com.factory.PeopleFactory">bean>

<bean id="peo" factory-bean="factory" factory-method="newInstance">
bean>

factory-bean指向factory的bean标签的id
factory-method指向factory中实例化对象的方法名

静态工厂实例化

静态工厂:不需要创建工厂,快速创建对象

public class PeopleFactory { 
    public static People newInstance(){ 
       return new People(11,"kryie");
    } 
}

<bean id="peo" class="cn.com.factory.PeopleFactory" factory-method="newInstance">bean>

通过class属性指定其对应的工厂实现类

Bean 的属性赋值(注入)

有参构造

可以通过构造方法设置值.

属性setter注入

属性为基本数据类型

  <bean id="peo" class="cn.com.pojo.People">
            <property name="id" value="11"/>
            <property name="name" value="kryie"/>
  bean>

当属性是list类型时

           <property name="list"> 
                <list> 
                    <value>1value> 
                    <value>2value> 
                    <value>3value> 
                list> 
            property>

当属性是数组时

<property name="strs" > 
   <array> 
      <value>1value> 
      <value>2value>
      <value>3value> 
   array> 
property>

当属性是set时

<property name="sets"> 
   <set> 
	   <value>1value>
	   <value>2value> 
	   <value>3value> 
   set> 
property>

当属性是map时

<property name="map"> 
       <map> 
              <entry key="a" value="b" > entry> 
              <entry key="c" value="d" > entry> 
       map> 
property>

当属性是Properties 类型时

<property name="demo"> 
   <props> 
      <prop key="key">valueprop> 
      <prop key="key1">value1prop> 
   props> 
property>

依赖注入(DI)

当属性为对象
当一个类(A)中需要依赖另一个类()对象时,把 B 赋值给 A 的过 程就叫做依赖注入

package cn.com.pojo;

public class School {
    private String name;
    private String address;
    //省略get和set方法
    @Override
    public String toString() {
        return "School{" +
                "name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

public class People {                                                  
    private int id;                                                    
    private String name;                                               
    private School school;    //包含了一个对象                                  
     //此处省略get和set方法                                                                                            
                                                                       
    @Override                                                          
    public String toString() {                                         
        return "People{" +                                             
                "id=" + id +                                           
                ", name='" + name + '\'' +                             
                ", school=" + school +                                 
                '}';                                                   
    }                                                                  
}                                                                      

<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="school" class="cn.com.pojo.School">
            <property name="name" value="sust"/>
            <property name="address" value="xian"/>
        bean>
        
        <bean id="peo" class="cn.com.pojo.People">
            <property name="id" value="11"/>
            <property name="name" value="kryie"/>
            <property name="school" ref="school"/>
        bean>
beans>

当属性是对象时，使用ref属性指向其需要实例化bean的id

 public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        System.out.println("------------获取bean----------------");
        People people=factory.getBean("peo", People.class);
        System.out.println(people);
        System.out.println(people.getSchool().getName());

    }
 }