【java框架】Spring(1) -

【java框架】Spring(1) -

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.RELEASElibs文件夹中导入核心包与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>

 

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框架去管理连接数,何时断开连接,合理分配资源。

①    在操作前,需要预先导入相应的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

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

<?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);
    }
}