Spring框架整体巩固学习第一部分

以你之姓@ 2024-02-18 00:40 15阅读 0赞

## 提供整理相关资源下载目录：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) 使用类的无参构造创建对象（重点☆☆☆☆☆☆） ####

类里面没有无参的构造，出现异常

#### 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中配置**

#### 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"*>

<!-- 注入属性

name属性值：类里面定义的属性名称

value属性：设置具体的值

\-->

<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"*>

<!-- 注入dao对象

name属性:类里面定义的属性名称

ref属性：dao配置bean标签中id值

\-->

<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创建对象**

**测试**

@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<String>lists;

**private** Map<String,String>maps;

**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<String> getLists() \{

**return**  lists;

**public void** setLists(List<String> lists) \{

**this**.lists =lists;

**public** Map<String, String> getMaps() \{

**return**  maps;

**public void** setMaps(Map<String,String> maps) \{

**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>

</list>

</property>

<propertyname=*"lists"*>

<list>

</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"*>sa</prop>

<propkey=*"pwd"*>123</prop>

</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章节）：

<?xml version="1.0" encoding="UTF-8"?><beans 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">

</beans>

<!-- 开启注解扫描

到包里面扫描类、方法、属性上面的是否有注解

\-->

<context:component-scanbase-package=*"cn.km"*></context:component-scan>

#### 3) 使用注解创建对象 ####

**定义实体**

**package** cn.km.po;

**import** javax.annotation.Resource;

**import**org.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")//注：相当于<bean id="user"class="cn.km.po.User"></bean>**

**//@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

#### 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;

**import**org.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>

**在需要的类中添加属性，并使用注解**

请查看上面代码

**测试**

@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;

**import**org.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>

<!-- 2.1 配置切入点

expression:配置切入点的表达式

id：切入点ID

\-->

<aop:pointcutexpression=*"execution(\* cn.km.aop.Book.\*(..))"*id=*"pointcut1"*/>

<!-- 2.2 配置切面

ref:作为切面的类的bean的ID

method:增强类中使用哪个方法作为前缀

pointcut\-ref:切入点的ID

\-->

<aop:aspectref=*"myBook"*>

<aop:before method=*"before1"* pointcut-ref=*"pointcut1"* />

<aop:after-returningmethod=*"after1"*pointcut-ref=*"pointcut1"*/>

<aop:aroundmethod=*"around1"*pointcut-ref=*"pointcut1"*/>

</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中进行配置如下:

<!-- 配置监听器

在类ContextLoaderListener中

\-->

<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>classpath:ApplicationContext.xml</param-value>

</context-param>

### 7. Spring的aop操作（基于注解方式） ###

#### 1) 准备工作 ####

添加注解约束

***http://www.springframework.org/schema/context***[**http://www.springframework.org/schema/context/spring-context.xsd**][http_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;

**import**org.aspectj.lang.annotation.Aspect;

**import**org.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** MyRowMapper**implements** RowMapper<User>\{

/\*\*

\* rs：查询返回的数据集

\* num：当前行数

\*/

@Override

**public** User mapRow(ResultSetrs, **int**num) **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<User> list =jdbcTemplate.query(sql,**new** MyRowMapper());

System.***out***.println(list);

**使用的自定的类与上面查询对象一样：**

**class** MyRowMapper**implements** RowMapper<User>\{

/\*\*

\* rs：查询返回的数据集

\* num：当前行数

\*/

@Override

**public** User mapRow(ResultSetrs, **int**num) **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>

②　创建jdbcTemplate对象，把模板对象注入到dao里面

<beanid=*"userDao"*class=*"cn.km.dao.UserDao"*>

<propertyname=*"jdbcTemplate"*ref=*"jdbcTemplate"*></property>

</bean>

③　向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层框架，提供不同的实现类**

<table> 
 <tbody> 
 <tr> 
 <td> org.springframework.jdbc.datasource.DataSourceTransactionManager </td> 
 <td> 使用Spring jdbc或ibatis进行持久化数据时使用 &nbsp; </td> 
 </tr> 
 <tr> 
 <td> &nbsp; </td> 
 <td> &nbsp; </td> 
 </tr> 
 </tbody> 
</table>

**③　配置事务管理器**

④　**使用事务的实例**

**使用XML配置方式**

**a. 创建数据表（sql语句）**

USE \[kmOA\]

SET ANSI\_NULLSON

SET QUOTED\_IDENTIFIERON

CREATE TABLE\[dbo\].\[userinfo\](

\[id\]  \[int\] NULL,

\[name\]  \[nvarchar\](50)NULL,

\[salary\]\[int\]NULL

) ON\[PRIMARY\]

**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(**int**id) \{

**this**.id =id;

**public** String getName() \{

**return**  name;

**public  void** setName(String name) \{

**this**.name =name;

**public  int** getSalary() \{

**return**  salary;

**public  void** setSalary(**int**salary) \{

**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全局配置文件比较全的约束 ####

<?xml version="1.0"encoding="UTF-8"?>

<beansxmlns="http://www.springframework.org/schema/beans"

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">

</beans>

### 12. 问题汇集 ###

缺少jar包aspectjweaver jar包

[http_www.springframework.org_schema_context_spring-context.xsd]: http://www.springframework.org/schema/context/spring-context.xsd

Spring框架整体巩固学习第一部分

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Spring Boot 框架整体启动流程详解

相关 Spring框架整体巩固学习第一部分

相关 PaddlePaddle 深度学习实战（第一部分）

相关 Git学习巩固

相关 342-学习TARS整体框架

相关剖析强化学习 - 第一部分

相关 Spring框架学习第一步

相关 spring cloud + vue + element 整体框架演示

相关【MyBatis框架】MyBatis入门程序第一部分

相关 Spring实战 | 第一部分 Spring的核心（第一章 Spring之旅）