Spring框架整体巩固学习 第一部分
提供整理相关资源下载目录：http://download.csdn.net/detail/u010879420/9921811
一、Spring简介
1．spring是开源的轻量级框架
2．spring核心主要两部分
(1) aop： 面向切面编程，扩展功能不是修改源代码实现
(2)ioc ： 控制反转，
---------比如一个类，在类里面有方法（不是静态方法），调用类里面的方法，创建类的对象，使用对象调用方法，创建类对象的过程，需要new出来对象
---------把对象的创建不是通过new方式实现，而是交给spring配置创建类对象
3．spring是一站式框架
spring在javaEE三层结构中，每一层都提供不同的解决技术
Web层：springMVC
SERVICE层：spring的ioc
dao层：spring的jdbcTemplate
4．spring版本
Spring4.X
5．Spring准备jar包
spring基础包：
spring-beans-4.2.5.RELEASE.jar
spring-context-4.2.5.RELEASE.jar
spring-core-4.2.5.RELEASE.jar
spring-expression-4.2.5.RELEASE.jar
日志包：
commons-logging-1.2.jar
log4j-1.2.17.jar
二、spring的bean管理
1. Bean实例化的方式
1) 使用类的无参构造创建对象（重点☆☆☆☆☆☆）
<bean id="User"class="cn.zzh.ioc.User">bean>
类里面没有无参的构造，出现异常
2) 使用静态工厂创建
创建静态方法，返回类对象。
创建实体
package cn.zzh.po;
public class Bean1 {
public void getname() {
System.out.println("Bean1__________");
}
}
创建工厂类
public class Bean1Factory {
public static Bean1 getBean1() {
returnnew Bean1();
}
}
XML中配置
<bean id="bean1"class="cn.zzh.BeanFactory.Bean1Factory"factory-method="getBean1">bean>
3) 使用实例工厂创建
创建不是静态的方法，返回类对象
创建实体
package cn.zzh.po;
public class Bean2 {
public void getname() {
System.out.println("Bean2__________");
}
}
创建工厂类
package cn.zzh.BeanFactory;
import cn.zzh.po.Bean2;
public class Bean2Factory {
public Bean2 getBean2() {
return new Bean2();
}
}
XML中配置
<beanid="bean2Factory"class="cn.zzh.BeanFactory.Bean2Factory">bean>
<beanid="bean2"factory-bean="bean2Factory"factory-method="getBean2">bean>
测试代码
@Test
public void testFactory2() {
ApplicationContext context =new ClassPathXmlApplicationContext("ApplicationContext.xml");
Bean2Factory bean2Factory = (Bean2Factory)context.getBean("bean2Factory");
Bean2 bean2 = (Bean2) context.getBean("bean2");
System.out.println(bean2);
bean2.getname();
}
2. Bean标签常用属性
1) Id
给Bean取得名称
2) Name
与Id属性的作用一样
3) Class
创建类的全路径
4) Scope
Bean的作用范围，其取值有：
Singleton：默认值，单例模式
Prototype：多例
Request：WEB项目中，Spring创建一个Bean的对象，将对象放入request中。
Session：WEB项目中，Spring创建一个Bean的对象，将对象放入session中。
globalSession：WEB项目中，Spring创建一个Bean的对象，将对象放入globleSession中。
3. 属性注入介绍
1) 使用参数构造注入
实体创建
package cn.zzh.po;
public class PropertyDemo {
private Stringname;
public PropertyDemo(Stringname) {
this.name =name;
}
public String getName() {
return name;
}
}
XML配置
<beanid="propertyDemo"class="cn.zzh.po.PropertyDemo">
<constructor-argname=""value="小米销毁11">constructor-arg>
bean>
测试
@Test
public void testPropertyDemo() {
ApplicationContext context =new ClassPathXmlApplicationContext("ApplicationContext.xml");
PropertyDemo propertyDemo = (PropertyDemo)context.getBean("propertyDemo");
System.out.println(propertyDemo.getName());
}
2) 使用set方式注入
实体创建
package cn.zzh.po;
public class Book {
private Stringbookname;
public void setBookname(String bookname) {
this.bookname =bookname;
}
public void getbookname(){
System.out.println(this.bookname);
}
}
XML配置
<beanid="book"class="cn.zzh.po.Book">
<propertyname="bookname"value="zzhua">property>
bean>
测试代码
@Test
public void testgetBookName() {
ApplicationContext context =new ClassPathXmlApplicationContext("ApplicationContext.xml");
Book book = (Book) context.getBean("book");
book.getbookname();
}
3) 注入对象类型属性（重点☆☆☆☆☆☆☆☆☆☆）
创建Dao类
package cn.zzh.dao;
public class PersionDao {
private Stringname;
public void setName(String name) {
this.name =name;
}
public void getName() {
System.out.println(this.name);
}
}
创建Service类
package cn.zzh.service;
import cn.zzh.dao.PersionDao;
public class PersionService {
private PersionDaopersionDao;
public PersionDao getPersionDao() {
return persionDao;
}
public void setPersionDao(PersionDao persionDao) {
this.persionDao =persionDao;
}
public void getname() {
System.out.println(persionDao);
persionDao.getName();
}
}
XML配置
<beanid="persionDao"class="cn.zzh.dao.PersionDao">
<propertyname="name"value="zzhuaq">property>
bean>
<beanid="persionService"class="cn.zzh.service.PersionService">
<propertyname="persionDao"ref="persionDao">property>
bean>
测试
@Test
public void testgetPersionName() {
ApplicationContext context =new ClassPathXmlApplicationContext("ApplicationContext.xml");
PersionService persionService = (PersionService)context.getBean("persionService");
persionService.getname();
}
4) P名称空间注入
实体类实现
package cn.zzh.dao;
public class PersionDao {
private Stringname;
public void setName(String name) {
this.name =name;
}
public void getName() {
System.out.println(this.name);
}
}
XML配置
【1】
在配置文件中添加一段约束
xmlns:p="http://www.springframework.org/schema/p",如下所示
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:p="http://www.springframework.org/schema/p"
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">
【2】配置bean创建对象
<bean id="persiondao"class="cn.zzh.dao.PersionDao"p:name="hanshiyong">bean>
测试
@Test
public void testpName() {
ApplicationContext context =new ClassPathXmlApplicationContext("ApplicationContext.xml");
PersionDao persionDao = (PersionDao)context.getBean("persiondao");
persionDao.getName();
}
5) 注入复杂类型属性
主要类型有：
① 数组
② list
③ map
④ Properties
具体代码演示
创建实体类，给实体类中添加各个复杂类型的属性
package cn.zzh.po;
import java.util.List;
import java.util.Map;
import java.util.Properties;
public class Item {
private Stringname;
private String[]items;
private List
private Map
private Propertiesproperties;
public String getName() {
return name;
}
public void setName(String name) {
this.name =name;
}
public String[] getItems() {
return items;
}
public void setItems(String[] items) {
this.items =items;
}
public List
return lists;
}
public void setLists(List
this.lists =lists;
}
public Map
return maps;
}
public void setMaps(Map
this.maps =maps;
}
public Properties getProperties() {
return properties;
}
public void setProperties(Properties properties) {
this.properties =properties;
}
public void test(){
System.out.println(items.length);
System.out.println(lists);
System.out.println(maps);
System.out.println(properties);
}
}
XML配置文件（重要）
<beanid="item"class="cn.zzh.po.Item">
<propertyname="items">
<list>
<value>小王value>
<value>小哈哈value>
<value>小吗value>
list>
property>
<propertyname="lists">
<list>
<value>111value>
<value>222value>
<value>333value>
<value>444value>
list>
property>
<propertyname="maps">
<map>
<entrykey="aa"value="aa">entry>
<entrykey="ww"value="ww">entry>
<entrykey="qq"value="qq">entry>
<entrykey="ff"value="ff">entry>
map>
property>
<propertyname="properties">
<props>
<propkey="username">saprop>
<propkey="pwd">123prop>
props>
property>
bean>
测试
@Test
public void testItem() {
ApplicationContext context =new ClassPathXmlApplicationContext("ApplicationContext.xml");
Item item = (Item) context.getBean("item");
item.test();
}
6) IOC和DI区别
IOC：控制反转，把对象创建交给spring进行配置
DI：依赖注入，向类里面的属性设置值
关系：依赖注入不能单独存在，需要在ioc基础上完成操作。
2017/7/27
4. Spring的bean
1) 注解的介绍
代码里面特殊标记，使用注解完成功能
注解写法 @注解名称（属性名称=属性值）
注解使用在类、方法、属性上面
2) Spring注解开发准备
导入使用的包
注解使用的包
创建全局配置文件，并添加约束
约束如下（在帮助文档/docs/spring-framework-reference/html/xsd-configuration.html中的40.2.8 the context schema章节）：
xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context" 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">
<context:component-scanbase-package="cn.km">context:component-scan>
3) 使用注解创建对象
定义实体
package cn.km.po;
import javax.annotation.Resource;
importorg.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;
//下面几种方式，效果相同（功能一样）
//@Component
//@Component(value="user")//注：相当于
//@Controller //WEB层
//@Controller(value="user")
//@Repository //持久层
//@Repository(value="user")
//@Service //业务层
@Service(value="user")//创建对象
@Scope(value="prototype")//创建对象是单实例（singletong）还是多实例prototype
public class User {
public void add(){
System.out.println("add..................");
}
}
直接测试使用
@Test
public void Test(){
ApplicationContext applicationContext =new ClassPathXmlApplicationContext("ApplicationContext.xml");
User user = (User) applicationContext.getBean("user");
user.add();
}
4) 单实例和多实例
给实体添加注解
多实例
//使用关键字@Scope创建对象是单实例（singleton）还是多实例prototype
@Scope(value="prototype") //多实例
@Scope(value="singleton") //单实例
public class User {
public void add(){
System.out.println("add..................");
}
}
测试
ApplicationContextapplicationContext =new ClassPathXmlApplicationContext("ApplicationContext.xml");
Useruser = (User) applicationContext.getBean("user");
System.out.println(user);
Useruser2 = (User) applicationContext.getBean("user");
System.out.println(user2);
测试输出（）
多实例输出（对象地址不同，不是同一对象）
cn.km.po.User@8a102f
cn.km.po.User@162806e
单实例输出（对象地址相同，同一对象）
cn.km.po.User@f60048
cn.km.po.User@f60048
5) 使用注解注入属性
① 创建实体类
② 通过注解方式创建对象，即在类名上方添加注解@Service(value="XXXXX")
③ 在需要属性的类中添加属性申明
④ 在属性申明上面添加注解，注入属性值
代码如下：
---------------------------------------------------------------------------------------------
package cn.km.dao;
import org.springframework.stereotype.Service;
@Service(value="userDao")//注解创建UserDao对象
public class UserDao {
public void add() {
System.out.println("add...................");
}
}
--------------------------------------------------
package cn.km.service;
import javax.annotation.Resource;
import org.springframework.beans.factory.annotation.Autowired;
importorg.springframework.stereotype.Service;
import cn.km.dao.UserDao;
@Service(value="userService")//注解方式创建对象UserService
public class UserService {
/**
* 通过注解方式得到dao对象
* 写注解创建对象的时候不需要set方法
有下面三中方式 Resource、@Resource(name="userDao") 、@Autowired
*/
@Resource(name="userDao")
//@Resource
//@Autowired
private UserDaouserDao;
public void add() {
System.out.println("serviceadd..............");
userDao.add();
}
}
测试
@Test
public void TestUserService(){
ApplicationContext applicationContext =new ClassPathXmlApplicationContext("ApplicationContext.xml");
UserService userService = (UserService)applicationContext.getBean("userService");
System.out.println(userService);
userService.add();
}
----------------------------------------------------------
输出结果
cn.km.service.UserService@1a561cf
serviceadd..............
add...................
6) XML和注解方式混合使用
创建实体类
package cn.km.dao;
public class BookDao {
public void getBookName(){
System.out.println("bookdao..............");
}
}
package cn.km.service;
import javax.annotation.Resource;
import cn.km.dao.BookDao;
public class BookService {
@Resource(name="bookDao") //注解给属性注入值
private BookDaobookDao;
public void add(){
System.out.println("service............");
bookDao.getBookName();
}
}
在XML文件中配置创建类的对象
<beanid="bookDao"class="cn.km.dao.BookDao">bean>
<bean id="bookService"class="cn.km.service.BookService">bean>
在需要的类中添加属性，并使用注解
请查看上面代码
测试
@Test
public void TestBookService(){
ApplicationContext applicationContext =new ClassPathXmlApplicationContext("ApplicationContext.xml");
BookService bookService = (BookService)applicationContext.getBean("bookService");
System.out.println(bookService);
bookService.add();
}
输出结果
cn.km.service.BookService@15e586c
service............
bookdao..............
三、Spring的AOP
1. Aop概述
2. Aop底层原理
3. Aop操作相关术语
1) 连接点：类里面哪些方法可以被增强，这些方法称为连接点
2) 切入点：在类里面可以有很多的方法被增强，比如实际操作中，只是增强了类里面的add方法和update方法，实际增强的方法称为切入点。
3) 通知/增强：增强的逻辑，称为增强，比如扩展日志功能，这个日志功能称为增强。
① 前置通知
② 后置通知
③ 异常通知
④ 最终通知
⑤ 环绕通知
4) 切面：把增强应用到具体方法上面，过程称为切面
4. Spring的aop操作（基于aspectj的XML方式）
在spring中进行aop操作，使用aspectJ实现
① aspectJ不是spring的一部分，和spring一起使用进行aop操作
② Spring2.0以后，新增了对aspectJ支持
使用aspectJ实现aop两种方式
③ 基于aspectJ的XML配置
④ 基于aspectJ的注解方式
1) Aop操作准备
① 除了导入基本的jar包之外，还需要导入aop相关jar包
aopalliance-1.0.jar
spring-aop-4.2.5.RELEASE.jar
spring-aspects-4.2.5.RELEASE.jar
Aspectjweaver jar包
② 创建spring核心配置文件，导入aop的约束
xmlversion="1.0"encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
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/aophttp://www.springframework.org/schema/aop/spring-aop.xsd">
beans>
2) 使用表达式配置切入点
切入点：实际增强的方法
常用的表达式，模板：
execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)
① execution(* cn.km.aop.Book.add(..)) //切入点为add方法
② execution(* cn.km.aop.Book.*(..)) //切入点为Book类中的所有方法
③ execution(* *.*(..)) //切入点为所有类中的所有方法
④ execution(* save*(..)) //匹配所有save开头的方法
3) 代码验证
① 创建实体，被增强的类
package cn.km.aop;
public class Book {
public void add(){
System.out.println("add...................");
}
}
② 创建实体，切面类
package cn.km.aop;
importorg.aspectj.lang.ProceedingJoinPoint;
public class MyBook {
//前置
public void before1(){
System.out.println("前置............");
}
//后置
public void after1(){
System.out.println("后置............");
}
//环绕通知
public void around1(ProceedingJoinPointjoinPoint) throws Throwable{
System.out.println("方法之前............");
//执行被增强的方法
joinPoint.proceed();
System.out.println("方法之后............");
}
}
③ XML配置
xmlversion="1.0"encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
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/aophttp://www.springframework.org/schema/aop/spring-aop.xsd">
<beanid="book"class="cn.km.aop.Book">bean>
<beanid="myBook"class="cn.km.aop.MyBook">bean>
<aop:config>
<aop:pointcutexpression="execution(* cn.km.aop.Book.*(..))"id="pointcut1"/>
<aop:aspectref="myBook">
aop:aspect>
aop:config>
beans>
④ 测试代码
@Test
public void Test(){
ApplicationContext applicationContext =new ClassPathXmlApplicationContext("ApplicationContext.xml");
Book book = (Book) applicationContext.getBean("book");
book.add();
}
⑤ 测试结果输出
前置............
方法之前............
add...................
方法之后............
后置............
5. Log4j介绍
1) 引入jar包
commons-logging-1.2.jar
log4j-1.2.17.jar
2) 添加属性配置文件
配置输出的级别
ERROR
DEBUG
INFO
WARN
6. Spring整合web项目
一般调用流程
Action调用 Service
Service调用 Dao层
在服务器启动的时候，创建对象加载配置文件
底层使用监听器、servletContext对象
1) 在spring中配置监听器
① 导入spring整合web项目的jar包
② 在Web.xml中进行配置如下:
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
listener>
<context-param>
<param-name>contextConfigLocationparam-name>
<param-value>classpath:ApplicationContext.xmlparam-value>
context-param>
7. Spring的aop操作（基于注解方式）
1) 准备工作
添加注解约束
http://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd
2) 在spring核心配置文件中，创建对象
<beanid="book"class="cn.km.aop.Book">bean>
<beanid="myBook"class="cn.km.aop.MyBook">bean>
3) 在spring核心配置文件中，开启aop操作
<aop:aspectj-autoproxy>aop:aspectj-autoproxy>
4) 在增强类上面使用注解完成aop操作
① 被增强类
package cn.km.aop;
public class Book {
public void add(){
System.out.println("add...................");
}
}
② 增强类
package cn.km.aop;
importorg.aspectj.lang.annotation.Aspect;
importorg.aspectj.lang.annotation.Before;
@Aspect
public class MyBook {
@Before(value="execution(*cn.km.aop.Book.*(..))")
public void before1(){
System.out.println("前置............");
}
}
5) @AspectJ提供不同的通知类型
@Before
@AfterReturning
@Around
@AfterThrowing
@After 最终通知
8. Spring的jdbcTemplate使用总结
1) 导入jdbc使用的jar包
2) 增加
3) 修改
4) 删除
5) 查询
Dbutils实现
jdbcTemplate实现查询，有接口RowMapper，
jdbcTemplate针对这个接口没有提供实现类，得到不同的类型的数据需要自己进行数据封装
① 查询返回某个值
@Test
public void testCount(){
//设置数据库信息
DriverManagerDataSource dataSource =new DriverManagerDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql:///spring_jdbc_0802");
dataSource.setUsername("root");
dataSource.setPassword("root");
//创建jdbcTemplate对象
JdbcTemplate jdbcTemplate =new JdbcTemplate(dataSource);
//调用方法得到记录数
String sql = "select count(*) fromuserInfo";
//调用jdbcTemplate方法
int count = jdbcTemplate.queryForObject(sql,Integer.class);
System.out.println(count);
}
② 查询返回对象
@Test
public void testObject(){
//设置数据库信息
DriverManagerDataSource dataSource =new DriverManagerDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql:///spring_jdbc_0802");
dataSource.setUsername("root");
dataSource.setPassword("root");
//创建jdbcTemplate对象
JdbcTemplate jdbcTemplate =new JdbcTemplate(dataSource);
//调用方法得到记录数
String sql = "select * from userInfowhere username=?";
//调用jdbcTemplate方法
//第二个参数是RowMapper，需要自己实现接口，做数据封装
User user = jdbcTemplate.queryForObject(sql,new MyRowMapper(),"Bob");
System.out.println(user);
}
自定义类
class MyRowMapperimplements RowMapper
/**
* rs：查询返回的数据集
* num：当前行数
*/
@Override
public User mapRow(ResultSetrs, intnum) throws SQLException {
String username = rs.getString("username");
String password = rs.getString("password");
User user = new User();
user.setUsername(username);
user.setPassword(password);
return user;
}
}
③ 查询返回List集合
Sql语句
RowMapper接口，自己写类进行封装
可变参数
@Test
public void testList(){
//设置数据库信息
DriverManagerDataSource dataSource =new DriverManagerDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql:///spring_jdbc_0802");
dataSource.setUsername("root");
dataSource.setPassword("root");
//创建jdbcTemplate对象
JdbcTemplate jdbcTemplate =new JdbcTemplate(dataSource);
//调用方法得到记录数
String sql = "select * fromuserInfo";
//调用jdbcTemplate方法
//第二个参数是RowMapper，需要自己实现接口，做数据封装
//后面可以跟参数即sql语句中的参数
List
System.out.println(list);
}
使用的自定的类与上面查询对象一样：
class MyRowMapperimplements RowMapper
/**
* rs：查询返回的数据集
* num：当前行数
*/
@Override
public User mapRow(ResultSetrs, intnum) throws SQLException {
String username = rs.getString("username");
String password = rs.getString("password");
User user = new User();
user.setUsername(username);
user.setPassword(password);
return user;
}
}
9. Spring配置连接池和dao使用jdbcTemplate
1) Spring配置c3p0连接池
① 导入jar包
Jar包mchange-commons-java-0.2.3.4.jar
② 创建spring配置文件
代码实现配置如下：
ComboPooledDataSource dataSource =new ComboPooledDataSource();
dataSource.setDriverClass("com.mysql.jdbc.Driver");
dataSource.setJdbcUrl("jdbc:mysql:///spring_jdbc_0802");
dataSource.setUser("root");
dataSource.setPassword("root");
把代码在配置文件中进行配置
<beanid="dataSource"class="com.mchange.v2.c3p0.ComboPooledDataSource">
<propertyname="driverClass"value="com.mysql.jdbc.Driver">property>
<propertyname="jdbcUrl"value="jdbc:mysql:///spring_jdbc_0802">property>
<propertyname="user"value="root">property>
<propertyname="password"value="root">property>
bean>
2) Dao使用jdbcTemplate
① 创建service和dao，配置service和dao对象，在service注入dao对象
<beanid="userService"class="cn.km.service.UserService">
<propertyname="userDao"ref="userDao">property>
bean>
<bean id="userDao" class="cn.km.dao.UserDao">
② 创建jdbcTemplate对象，把模板对象注入到dao里面
<beanid="userDao"class="cn.km.dao.UserDao">
<propertyname="jdbcTemplate"ref="jdbcTemplate">property>
bean>
<bean id="jdbcTemplate"class="org.springframework.jdbc.core.JdbcTemplate">
③ 向jdbcTemplate对象中注入dataSource
<beanid="jdbcTemplate"class="org.springframework.jdbc.core.JdbcTemplate">
<propertyname="dataSource"ref="dataSource">property>
bean>
10. Spring事物管理
1) 事物相关的概念
一组操作，一个失败，整体失败。
2) Spring事务管理API
① Spring事务管理有两种方式
第一种 编程式事务管理（不使用）
第二种 申明式事务管理
基于XML配置文件的
基于注解方式
接口PlatformTransactionManager为事务管理器
② Spring针对不同的dao层框架，提供不同的实现类
| org.springframework.jdbc.datasource.DataSourceTransactionManager |
使用Spring jdbc或ibatis进行持久化数据时使用
|
|
|
|
③ 配置事务管理器
④ 使用事务的实例
使用XML配置方式
a. 创建数据表（sql语句）
USE [kmOA]
GO
SET ANSI_NULLSON
GO
SET QUOTED_IDENTIFIERON
GO
CREATE TABLE[dbo].[userinfo](
[id] [int] NULL,
[name] [nvarchar](50)NULL,
[salary][int]NULL
) ON[PRIMARY]
GO
b. 创建Dao层和Service层
Dao层代码
package cn.km.dao;
import org.springframework.jdbc.core.JdbcTemplate;
public class UserDao {
private JdbcTemplatejdbcTemplate;
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate =jdbcTemplate;
}
private int id;
private Stringname;
private int salary;
public int getId() {
return id;
}
public void setId(intid) {
this.id =id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name =name;
}
public int getSalary() {
return salary;
}
public void setSalary(intsalary) {
this.salary =salary;
}
}
Service层代码
package cn.km.service;
import cn.km.dao.UserDao;
public class UserService {
private UserDaouserDao;
public void setUserDao(UserDao userDao) {
this.userDao =userDao;
}
}
c. 向Service层注入Dao对象
首先在Service类中添加Dao属性，生成set方法
然后在ApplicationContext.xml文件中添加如下：
<beanid="userService"class="cn.km.service.UserService">
<propertyname="userDao"ref="userDao">property>
bean>
<beanid="userDao"class="cn.km.dao.UserDao">
d. Dao对象中注入jdbcTemplate对象
<beanid="userDao"class="cn.km.dao.UserDao">
<propertyname="jdbcTemplate"ref="jdbcTemplate">property>
bean>
<beanid="jdbcTemplate"class="org.springframework.jdbc.core.JdbcTemplate">
e. jdbcTemplate对象中注入dataSource对象
<beanid="jdbcTemplate"class="org.springframework.jdbc.core.JdbcTemplate">
<propertyname="dataSource"ref="dataSource">property>
bean>
f. 创建dataSource对象
<beanid="dataSource"class="com.mchange.v2.c3p0.ComboPooledDataSource">
<propertyname="driverClass"value="com.mysql.jdbc.Driver">property>
<propertyname="jdbcUrl"value="jdbc:mysql:///spring_jdbc_0802">property>
<propertyname="user"value="root">property>
<propertyname="password"value="root">property>
bean>
g. 配置事务（重点）
使用注解方式
11. 附录
1) Spring全局配置文件比较全的约束
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" 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 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"> 缺少jar包aspectjweaver jar包12. 问题汇集