Spring框架入门详细说明
Spring快速入门
一、Spring框架配置
1、入门程序编写
程序包含如下4步：
导入包spring核心容器相关包
普通java类的建立
spring配置文件
通过spring内置API接口初始化spring容器，并获取spring 容器管理的java类的实例。
第1步：导包
导入Spring的核心包core、beans、context、expression。
spring-beans-4.3.2.RELEASE.jar
spring-context-4.3.2.RELEASE.jar
spring-core-4.3.2.RELEASE.jar
spring-expression-4.3.2.RELEASE.jar
以及commons-logging-1.2.jar日志包。
第2步：配置xml
Springconfig.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">
或者，在创建xml时，选择Spring Bean Configuration File来创建，会自动写入以上代码。
A. 构造器方式：
第3步：编写相关类:
我这边起名为：Stpring.java
public Stpring(String name,int age){
System.out.println(“name”);
System.out.println(“age”);
}
然后,再进入到Springconfig.xml中：
<bean id =constructor” class=”ts.Stpring.java”>
<constructor-arg index="0" value="bao" />
<constructor-arg index="1" value="18" />
constructor-arg标签：设定初始化bean的构造方法参数
index：构造方法参数位置，从0开始。
value：参数值。
spring根据constructor-arg标签判断调用哪个构造器初始化对象实例。
第4步：编写测试类：
Stest.java
public class Stest {
public static void main(String[] args) {
//(PS: 这里Springconfig.xml我是直接配置在src下。)
也可以用包名/Springconfig.xml
ClassPathXmlApplication cpxa = new ClassPathXmlApplication(Springconfig.xml);
Stpring sp = (Stpring) cxac.getBean("constructor");
} }
运行结果：
log4j:WARN No appenders could be found for
logger (org.springframework.core.env.StandardEnvironment).
log4j:WARN Please initialize the log4j system properly.
bao
18
B. 静态工厂方式
第1步：在Stpring中编写无参构造函数
public Stpring() {
System.out.println("静态工厂方式");
}
第2步：配置 Springconfig.xml配置文件
<bean id="staticdao" class="factory.Factory" factory-method="getFSpr" />
第3步：编写相关类 factory 包下的Factory.java
public static Stpring getFSpr(){
return new Stpring();
}
第3步：测试类 Stest.java
这里只需要将getBean中的ID改掉即可。
Stpring sp = (Stpring) cxac.getBean("staticdao");
运行结果：静态工厂方式
C. 普通工厂方式
第1步：在Stpring中编写方法
public void desc(){
System.out.println("这是普通工厂方式");
}
第2步：编写相关类 factory 包下的Factory.java
public Stpring getfactory(){
return new Stpring();
}
第3步：配置 Springconfig.xml配置文件
<bean id="factory" class="factory.Factory" />
<bean id="factorydao" factory-bean="factory" factory-method="getfactory" />
第4步：测试 Stest.java
ClassPathXmlApplicationContext cxac =
new ClassPathXmlApplicationContext("config/springconfig.xml");
Stpring sp = (Stpring) cxac.getBean("factorydao");
sp.desc();
D. bean初始化和销毁方法
第1步：在Stpring中编写初始化和销毁方法
public void istart(){
System.out.println("我是初始化方法");
}
public void dend(){
System.out.println("我是销毁方法");
}
第2步：配置 Springconfig.xml配置文件
<bean id="strart_destroy" class="factory.Factory"
init-method="istart" destroy-method="destroy"/>
第3步：测试 Stest.java
Factory sp = (Factory) cxac.getBean("strart_destroy");
cxac.close(); //因为需要调用销毁方法，所以这边需要调用close关闭方法。
结果：
我是初始化方法
我是销毁方法
二、Spring 基础知识
1、spring概述
1.1 Spring是什么？
Spring是一个高度灵活的轻量级框架，采用Java开发。
目的：为了解决企业级开发的复杂度。
1.2 Spring的功能介绍
提供IOC/DI(控制反转/依赖注入)，可以创建对象及管理对象之间的调用关系
提供AOP(面向切面编程方式)功能
提供MVC设计模式的解决方案
提供文件上传、定时器等常用工具类。
另外，还支持myBatis、Struts2、Hibernat等框架。
1.3 Spring功能模块划分
Core Container模块：
包含core、Beans、context、Expression language四个核心模块。
Core和Beans：基础模块，提供控制反转和依赖注入特性。
Context：构建在基础模块之上，ApplicationContext接口是context模块的关键。
Expression language：提供了强大的表达式语言，用于在运行时查找和操纵对象。
AOP&&Instrumentation模块：
AOP模块提供了一个符合AOP联盟标准的面向切面编程的实现。
DataAccess模块：
JBDC： 简化了访问数据库的方式 提供了一个JDBC抽象层。
ORM： 对象-关系映射框架。指将Java对象状态自动映射到关系数据库中的数据上，从而提供透明化的持久化支持。
Transactions：支持编程和声明式的事务管理。
Web模块：
Servlet： 包含了Spring的MVC(model-view-controller)设计模式。
Struts： 提供了对Struts的支持。
Test模块：
支持使用JUnit和testNG对Spring组件的测试。
三、Spring核心容器
IOC：控制反转。将控制权交给容器来进控制对象的创建及维护。反转：将对象的权利交给容器来进行处理。目的：获得更好的扩展性和可维护性。
IOC是通过Bean来进行控制的。
PS：代码示例： 在Spring框架配置中。
四、依赖注入 DI
依赖注入：通过web容器，动态的将依赖对象注入到另一个对象的组件中。
简单的说：就是将某些参数依赖注入到对象中。
Spring采用依赖注入方式为Bean的属性赋值。
注入方式：手动注入和注解
1、手动注入:
Setter方法 注入方式
Spring容器中通过调用Bean对应的setter方法来完成bean属性的赋值。
根据数据的不同可分为三种情况：
基本类型注入
基本类型注入泛指：当前bean组件的属性为基本类型、基本类型的封装类型、String、StringBuffer类型。
Spring组件类型注入：
8种基本类型及其封装类、String、StringBuffer
集合类型注入：
List Set Map 及数组
示例：
基本类型注入：
<bean id="setbasic" class="tx.Stpring" scope="prototype">
<property name="name" value="bao"></property>
</bean>
Spring组件类型：
<bean id="dog" class="tx.Stpring.Dog" />
<bean id="man" class="tx.Stpring.Spring" scope="prototype">
<property name="name" value="bao"></property>
<property name="dog" ref="dog"></property>
</bean>
集合类型注入：
集合注入
<bean id="list" class="tx.Stpring" scope="prototype">
<property name="age">
<list>
<value type="int">1</value>
<null></null>
<value type="int">3</value>
<value type="int">4</value>
</list>
</property>
</bean>
数组注入
<bean id="arys" class="tx.Stpring" scope="prototype">
<property name="array" >
<array>
<value>1</value>
<value>2</value>
</array>
</property>
</bean>
2、面向接口编程
面向接口编程：在程序设计或系统分析中，每个层级的程序并不是直接提供程序服务，而是定义一组接口，由接口的实现进行提供功能。面向接口编程实际上是面向对象的一部分。
1、使用注解 进行注入
在Spring3.0之后，增加组件自动扫描。它可以扫描到在指定类路径下添加了@Component、@Service、@Controller和@Repository注解的类。并将扫描到的类添加到Spring管理容器中进行管理。
自动扫描配置：
1、引入AOP包
2、在Springconfig.xml的NameSpaces中选中context和tx。
3、配置动态扫描
<context:component-scan base-package="tx.Stpring"></context:component-scan>
增加扫描并启动Spring容器后，Spring容器会查找在base-package目录下，配置
了Spring注解的类，并加载到Spring容器中去。
使用注解配置Spring组件
@Component：泛指组件，当组件不好归类时，使用此注解
@Service： 标注业务层组件
@Controller：标注控制处组件
@Repository：标注数据访问组件，即Dao组件
若是在注解中不写value，那么Bean中的id会是首字母小写的类名称形式。
五、AOP 的核心组件
切面(Aspect)：封装通用逻辑的组件，可以作用到其它组件上。
切入点(Pointcut)：指定哪些组件 哪些方法使用切面组件。Spring使用表达式来实现该指定。
通知： 指定组件作用到目标组件的具体位置。
前置通知：在目标组件的方法执行前执行
public class Point {
public void cutPoint(){
System.out.println("我是切点");
}
}
public class Advice {
public void cutAdvice(){
System.out.println("我是通知哦");
}
}
<bean id="point" class="com.spring_Aop.Point" />
<bean id="advicecut" class="com.spring_Aop.Advice"></bean>
<aop:config>
<aop:pointcut id="pointcut" expression="execution(* com.spring_Aop.Point.*(..))" />
<aop:aspect ref="advicecut">
<aop:before method="cutAdvice" pointcut-ref="pointcut"/>
</aop:aspect>
</aop:config>
Point pointcut = (Point) cac.getBean("point");
pointcut.cutPoint();
后置通知：在目标组件的方法执行并返回参数后执行；有返回值情况下才执行，若不配返回类型和返回值也执行；有异常时，不执行。
<bean id="point" class="com.spring_Aop.Point" />
<bean id="advicecut" class="com.spring_Aop.Advice"></bean>
<aop:config>
<aop:pointcut id="pointcut" expression="execution(* com.spring_Aop.Point.*(..))" />
<aop:aspect ref="advicecut">
<aop:after-returning method="afterAdvice" pointcut-ref="pointcut" returning="ref"/>
</aop:aspect>
</aop:config>
异常通知：在目标组件的方法抛出异常时执行
配置文件：
最终通知：在目标组件执行后或在异常执行通知前 执行
配置文件：
环绕通知：包含前4个通知，ProceedingJoinPoint参数。
@Resource注解：
手动注入时需要手动赋值；
@Value注解：
在属性添加注解完成注入，可以省略setter方法；只有在当前类为bean包时，才可以进行自动注入。
在spring中，接口和抽象类不可以打上注解。但MVC中可以。
六、spring的AOP机制
切入点表达式：切面程序要作用到哪些组件的哪些函数上。
常用的切入点表达式分为：
按类匹配：使用within关键字。 定位到类中的所有方法。
按方法匹配：匹配函数作为目标函数，使用execution关键字。 常用。
按bean的id匹配：匹配bean中全部的函数作为目标组件。使用bean关键字
按函数匹配
完整写法
返回类型 类的路径 类名 函数名 参数类型（用，分开）
execution(String com.chinasofti.Target.save(String))
Execution( 返回类型 类的路径 类名 函数名 参数类型（用，分开）)
AOP的注解配置：
前置通知注解方法：
@Component
@Aspect
public class Before {
@org.aspectj.lang.annotation.Before("execution(* com..*.*(..))")
public void doBefore(JoinPoint jp) {
}
}
后置通知注解方法：
@Component
@Aspect 返回值
public class After {
@AfterReturning(pointcut="execution(* com..*.*(..))",returning="ret")
public void doAfter(JoinPoint pjp,Object ret) {
System.out.println("目标程序与AOP程序执行后将最后执行,返回参数为" + ret);
}
异常通知注解方法：
@Component
@Aspect
public class ThrowException {
@AfterThrowing(pointcut="execution(* com..*.*(..))", throwing="e")
public void doThrow(JoinPoint jp , Throwable e) {
}
}
最终通知注解方法：
@Component
@Aspect
public class AfterFinally {
@After(value="execution(* com..*.*(..))")
public void afterFinally(JoinPoint jp) {
}
}
环绕通知注解方法：
@Component
@Aspect
public class Around {
@org.aspectj.lang.annotation.Around("execution(* com..*.*(..))")
public String around(ProceedingJoinPoint pjp) {
}
}
七、Spring集成工具类
Spring提供了JdbcTemple工具类，用于对jdbc的操作进行了轻量级别的封装。
优点：
直接使用sql语句操作数据库。
支持数据库的分区。
使用java语言拼sql语句。
使用spring集成jdbc包含如下几步：
导入集成包、连接池包。
初始化连接池数据源对象。
初始化JdbcTemplate对象。
调用JdbcTemplate的API接口完成数据库操作。
导入集成包、连接池包
org.springframework.jdbc-3.0.2.RELEASE.jar
该包封装并简化了jdbc的操作，JdbcTemplate就在此包内。
连接池包
com.springsource.com.mchange.v2.c3p0-0.9.1.2.jar c3p0连接池。
数据库驱动包
ojdbc6.jar /mysql-connector-java-5.1.40-bin.jar
初始化连接池数据源对象
初始化连接池数据源对象：
ComboPooledDataSource，该对象包含连接数据库的基本属性、连接池的配置属性。
初始化JdbcTemplate对象
通过spring的依赖注入设定Dao类继承的dataSource属性
<bean id="jdbcDao" class="org.springframework.jdbc.core.JdbcTemplate" >
<property name="dataSource" ref="datasource"></property>
</bean>
完整配置
spring集成jdbc
//数据的增删改查
* jdbcTemplate.update("insert into users(id,uname,password)value(?,?,?)", "1","啦啦","123");
jdbcTemplate.update("delete from users where id = ? ", 13);
jdbcTemplate.update("update users set uname=? ,password=? where id=?", "aaa","111",1);
//查询数据
List<Users> list = jdbcTemplate.query("select * from users where id = 1", new RowMapper<Users>(){
@Override
public Users mapRow(ResultSet res, int arg1) throws SQLException {
System.out.println(arg1);
Users users = new Users();
users.setId(res.getInt("id"));
users.setUname(res.getString("uname"));
users.setPassword(res.getString("password"));
return users;
}});
for (Users i : list) {
System.out.println(i);
}
查询数据（根据uname）：
Users users = jdbcTemplate.query("select * from users where uname = ?", new Object[]{"aaa"}, new ResultSetExtractor<Users>(){
@Override
public Users extractData(ResultSet reSet) throws SQLException, DataAccessException {
if(reSet.next()){
Users users = new Users();
users.setId(reSet.getInt("id"));
users.setPassword(reSet.getString("password"));
System.out.println(users);
return users;
}
return null;
}
});
八、jdbc的事物控制
事物的四大特性：
atomic(原子性):要么都发生，要么都不发生。
consistent(一致性):数据应该不被破坏。
isolate(隔离性):用户间操作不相混淆
durable(持久性):永久保存,例如保存到数据库中等
声明式事务管理
spring的事务管理器： spring没有直接管理事务，只是开发了事物管理器调用第三方组件完成事物控制。
READ_COMMITTED允许在并发事务已经提交后读取。
REPEATABLE_READ 对相同字段的多次读取是一致的，除非数据被事务本身改变。
SERIALIZABLE完全服从ACID的隔离级别。这在所有的隔离级别中是最慢的，它是典型的通过完全锁定在事务中涉及的数据表来完成的。
|
隔离级别 |
脏读 |
非重复读 |
幻像读 |
|
read uncommitted |
允许 |
允许 |
允许 |
|
read committed |
|
允许 |
允许 |
|
repeatable read |
|
|
允许 |
|
serializable |
|
|
|
8.1、使用Spring声明式 事物控制 分为如下几个部分：
1、配置事物控制管理器：jdbc的事物控制管理器为DataSourceTransactionManager
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="datasource"></property>
</bean>
2、配置事物通知：配置哪些函数(方法)委托spring进行事物管理，以及事物管理的隔离级别、传播行为、是否只读事物属性。
<tx:advice id="transaction" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="add*" isolation="DEFAULT" propagation="REQUIRED" read-only="false"/>
</tx:attributes>
</tx:advice>
3、配置事物的切入点：也就是spring的哪些组件要配置事物通知(建议放在service层)。
<aop:config>
<aop:pointcut expression="execution(* com.service.*.*(..))" id="point"/>
<aop:advisor advice-ref="transaction" pointcut-ref="point"/>
</aop:config>
8.2、使用注解完成事物控制
1、扫描包：
<context:component-scan base-package="com.dao"></context:component-scan>
<context:component-scan base-package="com.service"></context:component-scan>
2、写一个Dao类
UserDa.java 类
@Component
public class UserDao {
@Autowired
JdbcTemplate jTemplate;
public int insertUser(Users user){
return jTemplate.update("insert into
users(id,uname,password)value(?,?,?)",
user.getId(),user.getUname(),user.getPassword());
}
3、写一个Service类
UserService .java
@Service
public class UserService {
@Autowired
UserDao userdao;
public int addUser(Users user){
return userdao.insertUser(user);
}
}
4.测试类
DataSourceTransactionManager dataSourceTransactionManager =
new DataSourceTransactionManager();
public static void main(String[] args) {
ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("springconfig.xml");
UserService usService = (UserService) applicationContext.getBean("userService");
usService.addUser(new Users(100,"aa","123"));
applicationContext.close();
}
}