【java框架】Spring(1) -- Spring入门

Spring入门

1.   Spring认识

Spring是一个轻量级的DI（IOC）和AOP的容器框架。

IOC（Inverse of control）：控制反转，把业务层管理数据层生命周期的控制权交给Spring容器去管理，自己不再去管理数据层的生命周期（创建对象，销毁对象）。

DI（Dependence inject）：依赖注入，对象的创建和实例化不再通过原本new的方式，而是使用Spring进行对象注入。

AOP（Aspect Oriented Programming）：面向切面编程。通过预编译方式和运行期动态代理（在执行某件事情之前或者之后做一些其他事情）实现程序功能的统一维护的一种技术。AOP一般用于：日志记录、性能统计、安全控制、权限管理、事务处理、异常处理等。

 

2.   完成一个Hello World的Spring

2.1．导入jar包

Spring Framework框架下载可以到Spring的官方社区进行下载：

https://spring.io/projects/spring-framework

这里学习Spring Framework以老版本spring-framework-4.1.2.RELEASE为例。

在\spring-framework-4.1.2.RELEASE\libs文件夹中导入核心包与beans包：

 

2.2. 创建配置文件applicationContext.xml

配置文件的命名可以是：application.xml、application-context.xml、applicationContext.xml、beans.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="..." class="...">
        <!-- collaborators and configuration for this bean go here -->
    </bean>
</beans>

2.3. 完成Bean创建测试

import cn.yif.helloBean.MyBean;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

public class MyBeanTest {

    @org.junit.Test
    public void TestHello() {
        //读取资源文件applicationContext.xml
        Resource resource = new ClassPathResource("applicationContext.xml");
        //拿到核心对象BeanFactory
        BeanFactory factory = new XmlBeanFactory(resource);
        MyBean myBean = (MyBean)factory.getBean("myBean");
        System.out.println(myBean);
    }
}

3.   BeanFactory与ApplicationContext

BeanFactory与ApplicationContext都是Spring用来实例化、配置和管理对象的接口，都有获取getBean()的方法，它们两个创建对应的对象去获取Bean的方式都是一样的。

ApplicationContext是继承BeanFactory接口，相比于BeanFactory功能更强大，比如在国际化支持、资源访问（URL与文件）、事件传播等方面都有良好的支持。

3.1.   ApplicationContext的使用

导入jar包：

spring-context-4.1.2.RELEASE.jar

spring-expression-4.1.2.RELEASE.jar

获取Bean对象：

//读取资源文件applicationContext.xml
//拿到ApplicationContext核心对象
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
System.out.println("-------------实例化分割线--------------------");
//获取Bean同样具有三种方式：这里不再一一列出
MyBean myBean = (MyBean)applicationContext.getBean("myBean");
System.out.println(myBean);

相对于BeanFactory，ApplicationContext在加载对象时是迫切加载，在启动容器创建上下文环境的时候就创建Bean对象，而BeanFactory是懒加载，是在使用时才创建Bean对象。

3.2.  ApplicationContext配置懒加载

配置一：让所有Bean都变成懒加载，配置default-lazy-init="true"

<?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"
default-lazy-init="true">
    <bean id="myBean" class="cn.yif.helloBean.MyBean">
    </bean>
</beans>

配置二：让其中一个指定的Bean变成懒加载，配置lazy-init="true"

<bean id="myBean" class="cn.yif.helloBean.MyBean" lazy-init="true">
</bean>

 

4.   Spring的测试

传统的测试是java中自带的Junit4测试，如下图：

而Spring自带了一套自己的测试框架功能，如下图：

Spring的测试可以在配置文件不能读取的情况下（不启动服务器），自动读取相应的配置文件。

 

4.1. 完成Spring测试功能

导入对应的包：

spring-test-4.1.2.RELEASE.jar

spring-aop-4.1.2.RELEASE.jar

 

import cn.yif.testBean.TestBean;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * @RunWith:代表你现在使用哪一个Junit环境来做Spring
 * SpringJUnit4ClassRunner:代表是Junit4的测试环境，使用的是Spring的测试
 */
@RunWith(SpringJUnit4ClassRunner.class)
/**
 * ContextConfiguration：找到我们的核心配置文件
 * 这里配置路径有三种方式：
 * 方式一（web工程，正式开发时使用）：
 * /applicationContext.xml -> 从classpath的根目录开始(不建议使用)
 * classpath:cn/yif/helloBean/applicationContext.xml ->从classpath的根目录开始(正式开发)
 * 方式二(测试的时候使用)：
 * applicationContext.xml -> 当前目录下面开始查找
 * 方式三：(测试的时候使用)
 * 在当前目录下来创建xml的名称为：测试类名-Context.xml
 * 例：SpringTest-Context.xml
 * (使用这种方式，@ContextConfiguration可以不加参数)
 */
@ContextConfiguration("/applicationContext.xml")
//@ContextConfiguration()
public class SpringTest {
    @Autowired
    private ApplicationContext context;

    @Autowired
    private TestBean testBean;

    @Test
    public void testGetBean() {
        System.out.println(testBean);
    }

}

5.   Spring中Bean对象作用域

Bean配置节点中有个属性scope

这个可以让注入的Bean生成单例或者是多例；

默认是singleton，单例；

prototype，多例，比如struts2的action必须配置多例

<bean id="myBean" class="cn.yif.helloBean.MyBean" lazy-init="true" scope="singleton">
 </bean>
 <bean id="testBean" class="cn.yif.testBean.TestBean" scope="prototype">
 </bean>

 

使用prototype与singleton在实际中的区别：

①singleton在创建bean对象时只会创建一个，而prototype会创建多个（调用getBean()就会创建）；

②singleton在加载applicationContext.xml配置文件时就会创建Bean的实例，而prototype则是在调用getBean时实例化Bean。

6.   Spring的注入功能

6.1.基于普通类的注入

Spring普通类的注入方式：

基于Dao→Service→Action三层模型来说明：

①    首先在Action层面需要注入Service层的实现Impl类，使用@Autowired标签，并需要在类中提供Set方法，给注入的属性赋值；

 

②    同样的方式需要在Service中注入Dao实现类，并给予Set方法，赋值注入的属性；

 

③   配置对应的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="userDao" class="cn.yif.dao.impl.UserDaoImpl"></bean>
    <bean id="userService" class="cn.yif.service.Impl.UserServiceImpl">
        <!--name:注意这里的name值必须和UserServiceImpl类中的UserDaoImpl属性名称一致，而且必须提供set方法；
            否则无法注入
            ref：反向去找引用的哪个bean的id
            id:这里的bean中的id只是一个标识，id唯一就可以，命名没有要求-->
        <property name="userDao" ref="userDao"></property>
    </bean>
    <bean id="userAction" class="cn.yif.action.UserAction">
        <property name="userService" ref="userService"></property>
    </bean>
</beans>

6.2.获取JDBC连接池属性

Spring来管理JDBC连接池，可以使项目在运行时由Spring框架去管理连接数，何时断开连接，合理分配资源。

利用Spring获取applicationContext.xml配置时加载jdbc.properties配置文件获取连接信息。

①    在操作前，需要预先导入相应的dbcp的连接jar包，而且操作数据库，需要数据库的驱动包，具体需要导入：

com.springsource.org.apache.commons.dbcp-1.2.2.osgi.jar

com.springsource.org.apache.commons.pool-1.5.3.jar

mysql-connector-java-5.1.26-bin.jar

或者Maven配置如下：

<dependency>
     <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
     <version>5.1.26</version>
</dependency>
<dependency>
     <groupId>org.apache.commons</groupId>
     <artifactId>com.springsource.org.apache.commons.pool</artifactId>
     <version>1.5.3</version>
 </dependency>
 <!--<dependency>  jar包依赖错误，会报：Caused by:
  java.lang.ClassNotFoundException: org.apache.commons.dbcp.BasicDataSource-->
  <!--<groupId>org.apache.commons</groupId>-->
  <!--<artifactId>com.springsource.org.apache.commons.dbcp</artifactId>-->
  <!--<version>1.2.2.osgi</version>-->
  <!--</dependency>-->
 <dependency>
       <groupId>commons-dbcp</groupId>
       <artifactId>commons-dbcp</artifactId>
       <version>1.2.2</version>
</dependency>

在Maven中可能需要使用com.springsource.org.apache.commons.dbcp-1.2.2.osgi.jar包版本问题，建议做如上配置。

 

②    首先需要配置applicationContext.xml文件；

注意需要引入context命名空间和约束路径：

• 命名空间：xmlns:context="http://www.springframework.org/schema/context
• 约束路径：http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context.xsd

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd">
    <!--导入外部的jdbc.properties-->
    <context:property-placeholder location="classpath:jdbc.properties" />
    <!-- 配置一个DBCP的Bean destroy-method="close"：每次取用关闭连接池-->
    <bean id="dateSource" class="org.apache.commons.dbcp.BasicDataSource"
          destroy-method="close">
        <!-- 注意：这里我们不是使用的ref引用，而是直接写的value，因此注入的数据是一个变通的值 -->
        <property name="driverClassName" value="${jdbc.driverClassName}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>

</beans>

③   配置好jdbc.properties文件；

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring01_0305
jdbc.username=root
jdbc.password=admin

④    创建SpringJunit4测试；

import org.apache.commons.dbcp.BasicDataSource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.sql.Connection;
import java.sql.SQLException;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/applicationContext.xml")
public class SpringJDBCPoolTest {
    @Autowired
    private ApplicationContext applicationContext;

    @Test
    public void insert() {
        //使用ApplicationContext对象来获取bean对象
        BasicDataSource bean = applicationContext.getBean("dateSource", BasicDataSource.class);
        Connection connection = null;
        try {
            connection = bean.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        System.out.println(connection);
    }
}

 

本节Spring相关示例代码已上传至GitHub地址：

https://github.com/devyf/JavaWorkSpace/tree/master/Spring01_0304