这里写目录标题
IOP容器
一、IOC理论推导
1、传统创建方式
1.1、创建接口(Dao层)
创建接口和实现类
接口UserDao
package com.kuang.dao;
/*创建一个接口*/
public interface UserDao {
void getUser();
}
实现类UserDaoImpl
package com.kuang.dao;
/*接口实现类*/
public class UserDaoImpl implements UserDao {
public void getUser() {
System.out.println("默认获取用户的数据");
}
}
1.2、创建业务层(service层)
service接口:
package com.kuang.service;
public interface UserService {
void getUser();
}
实现类:
package com.kuang.service;
import com.kuang.dao.UserDao;
import com.kuang.dao.UserDaoImpl;
public class UserServiceImpl implements UserService {
/*想要调用dao层除了继承,还有一种组合的方式*/
private UserDao userDao = new UserDaoImpl();
public void getUser() {
userDao.getUser();
}
}
如何在service层调用dao层接口
- new一个实现类:
- 程序是主动创建的,控制权在程序员手上 new出来的对象是固定死的。
- 使用set接口进行动态注入(优化那里讲)
- 程序不再具有主动性,而是变成被动的接收对象
测试类:
用户不用去管dao接口层怎么实现,只需要去调用业务层代码即可。
import com.kuang.service.UserServiceImpl;
public class MyTest {
public static void main(String[] args) {
/*用户实际调用的是业务层(service),dao层他们不需要接触*/
UserServiceImpl userService = new UserServiceImpl();
userService.getUser();
}
}
1.3、使用接口编程存在的问题
当我们增加一个新的接口时,就要在业务层重新new对象。
1.4、解决上述问题(控制反转的思想)
修改后的UserServiceImpl类:
/*想要调用dao层除了继承,还有一种组合的方式*/
private UserDao userDao;
/*动态注入对象*/
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
import com.kuang.dao.UserDaoMysqlImpl;
import com.kuang.service.UserServiceImpl;
public class MyTest {
public static void main(String[] args) {
/*用户实际调用的是业务层(service),dao层他们不需要接触*/
UserServiceImpl userService = new UserServiceImpl();
userService.setUserDao(new UserDaoMysqlImpl());
userService.getUser();
}
}
思想本质
:程序员不用再去管对象的创建,对象的创建交给用户自己diy。系统的耦合性大大降低
2、IOC本质
2.1、IOC控制反转
获取依赖对象的方式反转了,原本对象是有业务层来创建的,现在是由用户自己来创建,降低了对象之间的耦合性。
2.2、IOC容器实现代码管理
创建一个ApplicationContext.xml文件,通过xml配置来实现对象的创建。标签中的bean标签就是相当于以前new的对象
标签与传统创建对象对比
- 类型 变量名 = new 类型();
- Hello hello = new Hello();
- 标签中的id等于变量名
- class相当于是new的对象
- property相当于给对象的属性设置一个值。
ApplicationContext.xml
<bean id="hello" class="com.kuang.pojo.Hello">
<property name="str" value="spring"></property>
</bean>
- value:具体的值,基本数据类型
- ref:引用spring中创建好的对象
<bean id="userdaoimpl" class="com.kuang.dao.UserDaoImpl"></bean>
<bean id="mysqlimpl" class="com.kuang.dao.UserDaoMysqlImpl"></bean>
<bean id="userserviceimpl" class="com.kuang.service.UserServiceImpl">
<property name="userDao" ref="mysqlimpl"></property>
</bean>
Test
public class MyTest {
public static void main(String[] args) {
//获取spring的上下文对象
ApplicationContext context = new ClassPathXmlApplicationContext("classpath:beans.xml");
//因为我们的对象都在spring中管理了,我们要做的就是去spring容器中取出即可
Hello hello = (Hello) context.getBean("hello");
System.out.println(hello.toString());
}
}
3、IOC创建对象的方式
3.1、使用无参构造创建对象(默认)
<bean id="hello" class="com.kuang.pojo.Hello">
<property name="str" value="spring"></property>
</bean>
3.2、使用有参构造创建对象
3.2.1、下标赋值
<bean id="user" class="com.kuang.pojo.User">
<constructor-arg index="0" value="渣渣鑫"></constructor-arg>
</bean>
3.2.2、直接通过参数名赋值
<bean id="user" class="com.kuang.pojo.User">
<constructor-arg name="name" value="渣渣鑫"></constructor-arg>
</bean>
2.3 总结
控制:谁来控制对象的创建,传统应用程序的对象是由程序本身控制创建的,使用spring后,对象是由spring来创建的。
反转:程序本身不创建对象,而是被动的接收对象
依赖注入:本身就是利用set方法进行注入的
4、Spring的配置
4.1、别名(alias)
可以将包名简化
4.2、bean的配置
之前讲解了
4.3、import
一般用于团队开发使用(合并配置文件)
二、DI依赖注入
1、构造器注入
2、Set方式注入【重点】
- 依赖:bean对象的创建依赖于容器
- 注入:bean对象中所有的属性,由容器来注入
2.1搭建环境
导入Spring依赖:
<!--4:spring依赖-->
<!--1)spring核心依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>4.1.7.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>4.1.7.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.1.7.RELEASE</version>
</dependency>
创建实体类:
2.1.1Address类
package com.kuang.pojo;
public class Address {
private Address address;
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
}
2.1.2student类(关键),就是要对创建的这些属性值进行注入
package com.kuang.pojo;
import java.net.ServerSocket;
import java.util.*;
public class Student {
private String name;
private Address address;//这里进行了set注入
private String[] books;
private List<String> hobbys;
private Map<String,String> card;
private Set<String> games;
private String wife;
private Properties info;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
public String[] getBooks() {
return books;
}
public void setBooks(String[] books) {
this.books = books;
}
public List<String> getHobbys() {
return hobbys;
}
public void setHobbys(List<String> hobbys) {
this.hobbys = hobbys;
}
public Map<String, String> getCard() {
return card;
}
public void setCard(Map<String, String> card) {
this.card = card;
}
public Set<String> getGames() {
return games;
}
public void setGames(Set<String> games) {
this.games = games;
}
public String getWife() {
return wife;
}
public void setWife(String wife) {
this.wife = wife;
}
public Properties getInfo() {
return info;
}
public void setInfo(Properties info) {
this.info = info;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", address=" + address +
", books=" + Arrays.toString(books) +
", hobbys=" + hobbys +
", card=" + card +
", games=" + games +
", wife='" + wife + '\'' +
", info=" + info +
'}';
}
}
2.1.3Aplicationcontext.xml配置文件
<bean id="address" class="com.kuang.pojo.Address">
<property name="address" value="山西阳泉"/>
</bean>
<bean id="student" class="com.kuang.pojo.Student">
<!--第一种,普通值注入,value-->
<property name="name" value="渣渣鑫"></property>
<!--第二种,bean注入,ref-->
<property name="address" ref="address"></property>
<!--数组注入-->
<property name="books">
<array>
<value>红楼梦</value>
<value>西游记</value>
<value>水浒传</value>
<value>三国演义</value>
</array>
</property>
<!--List注入-->
<property name="hobbys">
<list>
<value>听歌</value>
<value>敲代码</value>
<value>看电影</value>
</list>
</property>
<!--Map-->
<property name="card">
<map>
<entry key="身份证" value="1234567890"></entry>
<entry key="银行卡" value="111231434e"></entry>
</map>
</property>
<!--Set-->
<property name="games">
<set>
<value>LOL</value>
<value>COC</value>
<value>BOB</value>
</set>
</property>
<!--NULL注入-->
<property name="wife">
<null/>
</property>
<!--Properties-->
<property name="info">
<props>
<prop key="学号">2020100416</prop>
<prop key="性别">男</prop>
</props>
</property>
</bean>
2.1.4测试类
public class MyTest {
public static void main(String[] args) {
//获取spring的上下文对象
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//因为我们的对象都在spring中管理了,我们要做的就是去spring容器中取出即可
Student student = (Student) context.getBean("student");
System.out.println(student.toString());
}
}
2.1.5 测试结果
Student{name='渣渣鑫',
* address=Address{address='山西阳泉'},
* books=[红楼梦, 西游记, 水浒传, 三国演义],
* hobbys=[听歌, 敲代码, 看电影],
* card={身份证=1234567890, 银行卡=111231434e},
* games=[LOL, COC, BOB],
* wife='null', i
* nfo={学号=2020100416, 性别=男}}
2.1.6(注解)优化
导入lombok依赖:可以不用生成get和set代码,使用注解来解决
@Data
@NoArgsConstructor//无参构造
@AllArgsConstructor//所有构造
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.12</version>
<scope>provided</scope>
</dependency>
注解@Component(“别名”)等价于bean标签中的
bean id=“mailService” class=“com.zzx.service.MailService”/
依赖输入可以使用@Autowired注解,等价于
property name=“mailService” ref=“mailService”></property
@Service的底层实现还是@Component,这里用service是因为他说服务层,编写代码逻辑的包
2.1.6 总结
常用的注入就前面两种,一种是值的注入,一种是引用注入
3、拓展方式注入
p命名和C命名,需要导入xml约束
三、Bean的自动装配
重复代码要进行一 一对应,通过自动装配,可以直接匹配
3.1 在Spring中的三种装配模式
- 在xml中显示配置(已讲)
- 在Java中显示配置
隐式的自动装配
(重点)
3.2 隐式的自动装配
3.2.1 byname
会自动在容器上下文查找与自己对象set后面的值相对应的beanid。
吧id修改成dog111就不能自动匹配了,会报空指针异常
3.2.2 bytype
使用bytype就会解决上面存在的问题,bytype会自动在容器上下文查找和自己属性值类型相同的bean
4、使用注解自动装配
使用注解需要插入下面这条约束
xmlns:context="http://www.springframework.org/schema/context"
注解支持的引入
<!--注解的支持-->
<context:annotation-config/>
使用标签自动装配
如果有多个对象时。只使用@Autowired无法精准匹配到对象,就会报错,这时候加入Qualifier(value = “”)就可以继续使用了。
public class People {
@Autowired
private Cat cat;
@Autowired
@Qualifier(value ="dog1")
private Dog dog;
private String name;
四、使用注解开发
导入context约束
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
-
@Component(组件):放在类上,说明这个类被Sprig管理了
-
@Value(“渣渣鑫”)
对于复杂的DI依赖注入,注解就没有意义了,还是要使用配置文件。 -
@Component的衍生注解,本质还是一样的,只是在不同的层用了不同的注解
-
dao层:@Repository
-
service层:@Service
上面的注解都是一样的,都是讲某个类注册到spring容器中,装配bean
AOP代理模式
五、代理模式
代理模式就是中介的作用,让用户与厂家不直接接触,而是通过中介来联系。
5.1静态代理模式
- 抽象角色:(就是我们说的租房)一般会用接口或者抽象类来实现按。
- 真实角色:被代理的角色(出租房子的人)
- 代理角色:代理真是角色(中介)
- 客户:访问代理角色的人
代码开发步骤:
- 接口
package com.kuang.demo01;
/*租房的接口--抽象角色*/
public interface Rent {
/*出租房屋的方法*/
public void rent();
}
- 真实角色
/*房东是真实角色---租房子*/
public class Host implements Rent{
public void rent() {
System.out.println("房东要出租房子");
}
}
- 代理角色
/*代理---中介
* */
public class Proxy implements Rent{
/*这些是代理和房东的事情*/
private Host host;
public Proxy(Host host) {
this.host = host;
}
/*这是代理和租房的事情*/
public void rent() {
host.rent();
}
}
- 客户端访问代理角色
/*客户去租房子
* */
public class Client {
public static void main(String[] args) {
/* *//*传统租房子--客户直接俄找房东*//*
Host host = new Host();
host.rent();*/
/*先有一个房东*/
Host host = new Host();
//代理房东
Proxy proxy = new Proxy(host);
proxy.rent();
}
}
5.2代理模式的好处/与缺点
优点:
- 可以使真实角色的操作更加纯粹。不用去关注一些公共的业务
- 公共业务就交给代理角色完成
- 公共业务发生扩展的时候,方便集中管理
缺点:
- 一个真实的角色就会产生一个代理角色,代码量会翻一倍,开发效率低。
5.3动态代理模式
六、Spring AOP
6.1Spring官方文档
spring.io
-
AOP (Aspect Orient Programming),直译过来就是 面向切面编程。AOP 是一种编程思想,是面向对象编程(OOP)的一种补充。面向对象编程将程序抽象成各个层次的对象,而面向切面编程是将程序抽象成各个切面。
-
简单理解就是:把Aop当作是程序的一个插件,当程序想使用的时候就去启动它,不用操作源代码。同时该切面实现了跨越多个应用对象的逻辑。实现模块化。
6.2为什么需要Aop
- 简单来说就是实际开发过程中,涉及到多个地方具有相同的修改的问题,就可以使用Aop来解决。传统的办法就是给要重复执行的代码封装成一个方法。但是涉及到大量的增加和删除就会很复杂。Aop编程就很好的解决了这个问题。
- 提供声明式事务,允许用户自定义切面
6.3开发流程
6.3.1使用Spring的接口实现动态代理
创建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"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="
http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- bean definitions here -->
</beans>
引入依赖
<!--
https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.2.16.RELEASE</version>
</dependency>
讲横切关注点模块化成一个切面
package com.kuang.diy;
/*写一个切面*/
public class DiyPointCut {
public void before(){
System.out.println("=======方法执行前======");
}
public void after(){
System.out.println("=======方法执行后======");
}
}
编写自定义类标签
<!--方法二:自定义类,注册bean-->
<bean id="diy" class="com.kuang.diy.DiyPointCut"></bean>
<aop:config>
<!--自定义切面:ref要引用的类-->
<aop:aspect ref="diy">
<!--切入点-->
<aop:pointcut id="point" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"></aop:pointcut>
<!--通知-->
<aop:before method="before" pointcut-ref="point"></aop:before>
<aop:after method="after" pointcut-ref="point"></aop:after>
</aop:aspect>
</aop:config>
测试类
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userservice = (UserService) context.getBean("userService");
userservice.delete();
}
}
输出结果
6.4、PointCut切点表达式
去匹配com.imooc下的所有类的所有公用方法。
利用注解配置Aop
导入schema依赖。初始化IOC容器(comtext标签),使用来启动Spring Aop注解模式。
七、Mybatis-Spring
7.1、开发流程
7.1.1、编写数据源配置
<!--DataSource,使用spring的数据源替换Mybatis的配置-->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=UTF-8"></property>
<property name="username" value="root"></property>
<property name="password" value="010619"></property>
</bean>
7.1.2、sqlsessionfactory(固定不变的)
<!--sqlSessionFactory-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"></property>
<!--绑定mybatis-->
<property name="configLocation" value="classpath:mybatis-config.xml"></property>
<property name="mapperLocations" value="classpath:com/kuang/mapper/UserMapper.xml"></property>
</bean>
7.1.3、sqlsessionTemplate
<!--SqlSession-->
<bean id="sqlSesion" class="org.mybatis.spring.SqlSessionTemplate">
<constructor-arg index="0" ref="sqlSessionFactory"></constructor-arg>
</bean>
7.1.4、给接口加实现类
public class UserMapperImpl implements UserMapper {
//我们的所有操作,都使用sqlSession来执行,现在使用SqlSessionTemplate
private SqlSessionTemplate sqlsession;
public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
this.sqlsession = sqlSessionTemplate;
}
public List<User> selectUser() {
UserMapper mapper = sqlsession.getMapper(UserMapper.class);
return mapper.selectUser();
}
public void setSqlsession(SqlSessionTemplate sqlsession) {
this.sqlsession = sqlsession;
}
public SqlSessionTemplate getSqlsession() {
return sqlsession;
}
}
7.1.5、将自己写的类注入到spring中去
<bean id="userMapper" class="com.kuang.mapper.UserMapperImpl">
<property name="sqlsession" ref="sqlSesion"></property>
</bean>
7.1.6、测试
ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
for (User user :userMapper.selectUser())
{
System.out.println(user);
}
依赖的注入
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.0.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.0.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
<scope>runtime</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.2</version>
</dependency>
</dependencies>
7.2、遇到的问题
八、Spring事务的理解
事务:
特性就是要么都成功,要么都失败
事务在项目开发中很重要,确保项目的完整性和一致性。
事务的ACID原则:
- A:代表原子性
- C:一致性
- I:隔离性
- 多个业务可能操作同一个资源,防止数据损坏。 - D:持久性
- 事务一旦提交无论系统发生什么问题,结果都不会被影响,被持久化写到数据存储器中。
8.1、开发流程
1、导入依赖:
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.0.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.0.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
<scope>runtime</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.12</version>
<scope>provided</scope>
</dependency>
</dependencies>
2、创建包:
pojo包:就是普通代码包,主要写一些实体类
与数据库的字段名匹配
@Data
public class User {
private int id;
private String name;
private String pwd;
}
3、写完实体类就要去写接口(UserMapper)
接口里面写增删改查的方法
public interface UserMapper {
public List<User> selectUser();
}
4、导入mybatis配置
mybatis-config.xml
因为使用spring配置,所以mybatis-config.xml的配置都写到spring中去了。
这里主要写别名的标签即可
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!--起别名-->
<typeAliases>
<package name="com.kuang.pojo" ></package>
</typeAliases>
</configuration>
5、整合spring(常见spring-dao.xml)
- 第一步:配置数据源
- 第二步:sqlSessionFactory
- 第三步:SqlSessionTemplate
<?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:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="
http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
<!--DataSource,使用spring的数据源替换Mybatis的配置-->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=UTF-8"></property>
<property name="username" value="root"></property>
<property name="password" value="010619"></property>
</bean>
<!--sqlSessionFactory-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"></property>
<!--绑定mybatis-->
<property name="configLocation" value="classpath:mybatis-config.xml"></property>
<property name="mapperLocations" value="classpath:com/kuang/mapper/UserMapper.xml"></property>
</bean>
<!--SqlSession-->
<bean id="sqlSesion" class="org.mybatis.spring.SqlSessionTemplate">
<constructor-arg index="0" ref="sqlSessionFactory"></constructor-arg>
</bean>
</beans>
6、创建usermapper.xml(编写sql语句的标签)
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.kuang.mapper.UserMapper">
<!--书写则删改查语句-->
<select id="selectUser" resultType="user">
/*查询全部用户*/
SELECT * FROM mybatis.user;
</select>
</mapper>
7、编写实现类来操作
public class UserMapperImpl implements UserMapper {
//我们的所有操作,都使用sqlSession来执行,现在使用SqlSessionTemplate
private SqlSessionTemplate sqlsession;
public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
this.sqlsession = sqlSessionTemplate;
}
public List<User> selectUser() {
UserMapper mapper = sqlsession.getMapper(UserMapper.class);
return mapper.selectUser();
}
public void setSqlsession(SqlSessionTemplate sqlsession) {
this.sqlsession = sqlsession;
}
public SqlSessionTemplate getSqlsession() {
return sqlsession;
}
}
8.2运行错误