Spring-Framework

Spring-Framework 搭建、基础操作

Spring简介

Spring官网
Spring是一个开源框架，或者说是一个轻量级的容器，为解决企业应用程序开发的复杂性而生。Spring可以针对Bean的生命周期进行管理并且具有良好的分层架构，其核心为IOC(反转控制)，采用了AOP(面向切面编程)思想，同时也提供与其他流行的Web应用框架的整合方案，包括Struts2、Hibernate、Mybatis等。

Spring架构

spring-overview

Spring框架搭建

导包

jar

导入约束

xsd

创建类

定义接口

1
2
3

public interface HelloDao {
	void hello();
}

接口实现类

public class HelloDaoImpl implements HelloDao {
	@Override
	public void hello(){
		System.out.println("Hello Spring !");
	}
}

设置配置文件

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	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
		http://www.springframework.org/schema/aop
		http://www.springframework.org/schema/aop/spring-aop.xsd ">
	<bean name="hello" class="com.my.dao.HelloDaoImpl"></bean>
</beans>

IOC与DI

IOC (Inversion of Control的缩写)，即控制反转；DI (Dependency Injection的缩写)，即依赖注入。IOC与DI是面向对象编程中的一种设计原则，其作用就是降低代码之间的耦合度，即各个模块之间的关联度。在Java中，代码耦合的根本原因就是使用new 调用构造方法创建对象，如果各个模块之间都使用new的方式来创建其所依赖的对象，将会导致不同模块之间的代码耦合度变高，这就意味着代码的维护和调试成本将被提高。而IOC正是为此而生，所谓控制反转，即由原来各个模块自己创建对象反转为将对象的创建交个一个容器(可以将其理解为一个第三方的机构)帮助我们进行创建和管理，各模块所依赖的对象只需要对容器中创建的对象进行引用即可。依赖注入正是将引用注入到依赖对象中，这样依赖的对象就与容器中的对象产生了关联，最终达到松耦合的目的。Spring框架在设计上也采用了这种设计原则，因此Spring能够很好地帮助我们管理对象以及对象之间的依赖关系。

Spring注解

Spring
@Component(“user”)相当于
@Service：Service层注解
@Controller：Web层注解
@Repository：Dao层注解
@Scope(scopeName=”singleton”)
@Value(“Alibaba”)
@PostConstruct
@PreDestroy

Spring与Junit整合测试

package com.my.junit;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.my.bean.User;

// 使用注解创建Spring容器
@RunWith(SpringJUnit4ClassRunner.class)
// 指定创建容器使用哪个配置文件
@ContextConfiguration("classpath:applicationContext.xml")
public class JunitDemo {

    // 将名为user的对象注入到user变量中
    @Resource(name="user")
    private User user;
    
    @Test
    public void fun() {
        System.out.println("This is a test !" + user);
    }
}

AOP思想

AOP（Aspect Oriented Programming）即面向切面编程，其主要的作用就是分离程序的业务逻辑与系统级服务（日志、权限认证、事务管理等）。过滤器、拦截器、动态代理都蕴含了AOP思想。

Spring AOP名词

切面(Aspect): 一个关注点的模块化
切入点(Pointcut): 匹配连接点的断言。
连接点(Joinpoint): 程序在执行过程中某个特定的点
通知(Advice): 在切面的某个特定的连接点上执行的动作
目标对象(Target Object): 被一个或者多个切面所通知的对象
织入(Weaving): 把切面连接到其他的应用程序类型或者对象上，并创建一个被通知的对象
引入(Introduction) 在不修改类代码的前提下，为类添加新的方法和属性

通知(Advice)的类型

通知类型	描述
前置通知(Before Advice)	在连接点之前执行的通知，但不能阻止连接点前的执行
后置通知(After Returning Advice)	在连接点正常执行完后执行的通知
后置通知(After finally Advice)	当连接点退出的时候执行的通知（无论是否出现异常）
环绕通知(Around Advice)	连接点之前和之后都会执行的通知
异常通知(After Throwing Advice)	在方法抛出异常退出时执行的通知

Spring Jdbc

Spring Jdbc操作数据库

Spring中整合了Jdbc对数据库操作，在JdbcTemplate类中提供一系列操作数据库的方法，使用JdbcTemplate类对象操作数据库有点类似于QueryRunner，那么如何去使用JdbcTemplate类操作数据库？方法一：在DAO层接口的实现类中声明一个JdbcTemplate对象，并且提供set方法，然后在配置文件对此对象进行注入，并且在配置文件中配置DataSource，因为JdbcTemplate需要通过连接池连接数据库，除此之外还需要将DAO层接口的实现类配置到spring中，那么在需要进行数据库操作的时候，只需要声明一个xxxDao接口对象，将spring配置文件中的配置的xxxDao注入到声明的对象中即可，具体的配置如下：

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
        xmlns="http://www.springframework.org/schema/beans" 
        xmlns:context="http://www.springframework.org/schema/context" 
        xmlns:aop="http://www.springframework.org/schema/aop" 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 http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd ">
	<!-- 配置思路：Dao依赖于jdbcTemplate,jdbcTemplate依赖于DataSource -->	
	<!-- 1.将连接池配置到spring容器中 -->
	<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<!-- 使用set方式向DataSource中注入属性 -->
		<property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
		<property name="jdbcUrl" value="jdbc:mysql:///spring?useSSL=false&amp;serverTimezone=GMT%2B8"></property>
		<property name="user" value="mackvord"></property>
		<property name="password" value="12345678"></property>
	</bean>
	<!-- 将Jdbctemplate配置到spring容器中-->
	<bean name="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	<!-- 将xxxDao配置到spring容器中 -->
	<bean name="xxxDao" class="com.my.jdbctemplate.xxxrDaoImpl">
		<property name="jt" ref="jdbcTemplate"></property>
	</bean>
</beans>

第二种方法是直接继承JdbcDaoSupport类，JdbcDaoSupport类会根据DataSource自动创建JdbcTemplate类实例，也就是说我们不用再在DAO层手动声明一个JdbcTemplate对象并进行注入，相比上面的方法，这种方法不用再将JdbcTemplate配置spring容器中，而是直接在xxxDaobean中引用dataSource即可

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
        xmlns="http://www.springframework.org/schema/beans" 
        xmlns:context="http://www.springframework.org/schema/context" 
        xmlns:aop="http://www.springframework.org/schema/aop" 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 http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd ">
	<!-- 1.将连接池交给spring容器管理 -->
	<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<!-- 使用set方式向DataSource中注入属性 -->
		<property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
		<property name="jdbcUrl" value="jdbc:mysql:///spring?useSSL=false&amp;serverTimezone=GMT%2B8"></property>
		<property name="user" value="mackvord"></property>
		<property name="password" value="12345678"></property>
	</bean>
	<!-- 将Jdbctemplate交给spring容器管理 -->
	<!-- <bean name="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean> -->
	<!-- 将UserDao交给spring容器管理 -->
	<bean name="xxxDao" class="com.my.jdbctemplate.xxxDaoImpl">
		<!-- <property name="jt" ref="jdbcTemplate"></property> -->
		<!-- 如果Dao继承了JdbcDaoSupport类，那么就无需再手动配置jdbctemplate，只需要将DataSource注入到daobean中即可 -->
		<property name="dataSource" ref="dataSource"></property>
	</bean>
</beans>

关于配置dataSource，即配置数据库的驱动、连接地址、用户和密码。还有另外一种方式，不是直接在spring中配置，而是将这些信息配置到资源文件中，spring直接从资源文件中读取。

applicationContext.xml

<!-- 指定spring读取properties中的配置 -->
<context:property-placeholder location="classpath:db.properties" />
<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
	<property name="driverClass" value="${jdbc.driverClass}"></property>
	<property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
	<property name="user" value="${jdbc.user}"></property>
	<property name="password" value="${jdbc.password}"></property>
</bean>

db.properties

jdbc.driverClass=com.mysql.cj.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql:///spring?useSSL=false&serverTimezone=GMT%2B8
jdbc.user=mackvord
jdbc.password=12345678

Tips
在xml文件中配置数据库连接地址的时候，后面的参数之间使用&连接，而在properties文件中&符号连接，两者本质上是一样的，前者是转义字符。

Spring事务管理

我们知道，对于不同的数据库平台，其操作的代码的是不一样的，为了解决这个问题，Spring提供一个可针对不同平台进行不同处理的接口PlatformTransactionManager,并且封装了此接口的不同实现，包括JDBCTransactionManager，HibernateTransactionManager，MybatisTransactionManager。