Spring-Mybatis整合从零开始

创建项目

1.通过maven的方式创建一个项目

2.创建POJO对象

public class Hello {private String str;public void setStr(String str) {this.str = str;}public String getStr(){return str;}@Overridepublic String toString() {return "Hello{" +"str='" + str + '\'' +'}';}}

然后创建 beans.xml (applicationContext.xml），在xml中配置相应的属性

3.之后就可以调用这个POJO类了

//使用xml加载就必须用下面的语法//获取spring的上下文对象ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");//对象都在Spring中管理，要使用就直接取出来用Hello h = (Hello) context.getBean("hello");System.out.println(h.toString());

通过set()注入

IOC创建对象的方式

1.先编写POJO对象

    public class User {private String name;public String getName() {return name;}public void setName(String name) {this.name = name;}public User(){System.out.println("无参构造");}public void show(){System.out.println("name:"+name);}}

2.在applicationContext.xml文件中添加bean

    <?xml version="1.0" encoding="UTF-8"?><!-- applicationContext.xml --><beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="user" class="com.ckl.pojo.User"><property name="name" value="ckl"/></bean></beans>

3.通过测试可以发现，IOC通过无参构造注入

  public class MyTest {public static void main(String[] args) {//User user = new User();ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");User user = (User)context.getBean("user");//System.out.println(user);user.show();}}当没有无参构造时，有以下的方式进行构造函数注入<!--    有参构造注入：1.下标赋值--><!--    <bean id="user" class="com.ckl.pojo.User">--><!--        <constructor-arg index="0" value="ckl"/>--><!--    </bean>--><!--    2.通过类型创建，可能会出现相同类型的，不建议使用--><!--    <bean id="user" class="com.ckl.pojo.User">--><!--        <constructor-arg type="java.lang.String" value="ckl"/>--><!--    </bean>--><!--    3.通过参数名设置--><bean id="user" class="com.ckl.pojo.User"><constructor-arg name="name" value="ckl"/></bean>

总结： 在配置文件加载的时候，容器中管理的对象就已经初始化了(不管你有没有调用).

Spring配置

1.别名

  <bean id="user" class="com.ckl.pojo.User"><property name="name" value="ckl"/></bean><!--    给id取别名--><alias name="user" alias="UUU"/>

通过别名也可以获取到bean

    ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");User user = (User)context.getBean("UUU");

2.Bean的配置

     <bean id="user" class="com.ckl.pojo.User" name="u,u1,u2"><property name="name" value="ckl"/></bean><!--id:bean的唯一标识符class:bean对象所对应的全限定名name:也是别名，而且name可以同时取多个别名 -->

3.import

一般用于团队开发使用，可以将多个配置文件导入合并为一个

项目中有多个配合文件，就可以在总的配置文件中，通过import进行导入

依赖注入(DI)

1.构造器注入

2.set()方式注入[*]

依赖：bean对象的创建依赖于容器
注入：bean对象中所有的属性，由容器来注入

【环境搭建】

1.复杂类型

    public class Address {private String address;public String getAddress() {return address;}public void setAddress(String address) {this.address = address;}}

2.真实测试对象

    public class Student {private String name;private Address address;private String[] books;private List<String> hobbys;private Map<String,String> card;private Set<String> games;private String wife;private Properties info;}

3.applicationContext.xml

    <?xml version="1.0" encoding="UTF-8"?><!-- applicationContext.xml --><beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="address" class="com.ckl.pojo.Address"/><bean id="student" class="com.ckl.pojo.Student"><!--    1.普通值注入,value--><property name="name" value="ckl"/><!--    2.Bean注入,ref--><property name="address" ref="address"/><!--    3.数组注入,ref--><property name="books"><array><value>红楼梦</value><value>三国演义</value><value>西游记</value><value>水浒传</value></array></property><!--    4.List注入,ref--><property name="hobbys"><list><value>听歌</value><value>看电影</value></list></property><!--    5.Map注入,ref--><property name="card"><map><entry key="身份证" value="4564654131"/><entry key="银行卡" value="4561231"/></map></property><!--     6.set注入    --><property name="games"><set><value>LOL</value><value>CSGO</value></set></property><!--        null--><property name="wife"><null/></property><!--    properties    --><property name="info"><props><prop key="学号:">001</prop><prop key="性别">男</prop><prop key="username">root</prop><prop key="userpassword">123465</prop></props></property></bean></beans>

4.测试

    public class MyTest {public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");Student student = (Student)context.getBean("student");System.out.println(student.toString());//此时只有name有值}}/* 打印：Student{name='ckl', address=Address{address='null'}, books=[红楼梦, 三国演义, 西游记, 水浒传], hobbys=[听歌, 看电影], card={身份证=4564654131, 银行卡=4561231}, games=[LOL, CSGO], wife='null', info={性别=男, userpassword=123465, 学号:=001, username=root}}*/

3.其他方式

bean的作用域

1.单例模式(默认机制)

    <bean id="address" class="com.ckl.pojo.Address" scope="singleton"/>

2.原型模式：每一次从容器中get都会产生新的对象

    <bean id="address" class="com.ckl.pojo.Address" scope="prototype"/>

3.其余的request、session、application、这些只能在web开发中用到

Bean的自动装配

之前的是手动装配

自动装配是Spring满足bean依赖一种方式
Spring会在上下文中自动寻找，并自动给bean装配属性

在Spring中有 3 种方式：

在xml中显示的配置
在java中显示配置
隐式的自动装配bean[*]
在xml中显示的装配

    <?xml version="1.0" encoding="UTF-8"?><!-- applicationContext.xml --><beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="cat" class="com.ckl.pojo.Cat"/><bean id="dog" class="com.ckl.pojo.Dog"/><bean id="people" class="com.ckl.pojo.People"><property name="name" value="ckl"/><property name="cat" ref="cat"/><property name="dog" ref="dog"/></bean></beans>

通过ByName的方式：需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致

    <!--    byName : 会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanid--><bean id="cat" class="com.ckl.pojo.Cat"/><bean id="dog" class="com.ckl.pojo.Dog"/><bean id="people" class="com.ckl.pojo.People" autowire="byName"><property name="name" value="ckl"/></bean>

通过byType的方式（不用命名id也能找到）：需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性的类型一致

    <!--    byType : 会自动在容器上下文中查找，和自己对象属性类型相同的bean--><bean  class="com.ckl.pojo.Cat"/><bean  class="com.ckl.pojo.Dog"/><bean id="people" class="com.ckl.pojo.People" autowire="byType"><property name="name" value="ckl"/></bean>

注解自动装配

使用注解：

导入约束。context约束
配置注解的支持

<?xml version="1.0" encoding="UTF-8"?><!-- applicationContext.xml --><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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"><!-- 注解支持开启--><context:annotation-config></context:annotation-config></beans>

    public class People {@Autowiredprivate Cat cat;@Autowiredprivate Dog dog;private String name;}

@Autowired

直接在属性上使用，也可以在set方法上使用

使用Autowired我们可以不写set方法，前提是你这个自动装配的属性在IOC容器中存在，且符合名字byName

    <bean id="cat1" class="com.ckl.pojo.Cat"/><bean id="dog1" class="com.ckl.pojo.Dog"/><bean id="cat2" class="com.ckl.pojo.Cat"/><bean id="dog2" class="com.ckl.pojo.Dog"/><bean id="people" class="com.ckl.pojo.People" />

    public class People{@Autowired@Qualifier(value = "cat1")//在找不到的时候可以时候该注解找到对应的valueprivate Cat cat;@Autowired@Qualifier(value = "dog1")private Dog dog;private String name;}

@Resource

先根据id找，找不到时根据类型type找，当都找不到时报错

    public class People {@Resourceprivate Cat cat;@Resourceprivate Dog dog;private String name;}

小结：@Autowired 和 @Resource 区别：

都是用来自动装配的，都可以放在属性字段上
@Autowired通过byType方式实现，而且必须要求这个对象存在（不然包控制着）
@Resource默认通过byName方式实现，找不到时通过byType方式实现，都找不到就报错执行
执行顺序不同：@Autowired通过byType实现。@Resource通过byName方式实现

使用注解开发

在spring4之后，要使用注解开发，必须保证aop的包导入

使用注解需要导入context约束，增加注解支持

    <?xml version="1.0" encoding="UTF-8"?><!-- applicationContext.xml --><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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttps://www.springframework.org/schema/context/spring-context.xsd"><!--    指定扫描路径下的包，这个包下的注解就会生效--><context:component-scan base-package="com.ckl.pojo"/><!--    注解支持--><context:annotation-config/></beans>

1.bean

@Component

组件，放在类上，说明这个类被spring管理，就是bean

    //@Component 等价于 <bean id = "user" class="com.ckl.pojo"/>@Componentpublic class User {public String name = "ckl";}

    <?xml version="1.0" encoding="UTF-8"?><!-- applicationContext.xml --><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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttps://www.springframework.org/schema/context/spring-context.xsd"><!--    指定扫描路径下的包，这个包下的注解就会生效--><context:component-scan base-package="com.ckl.pojo"/></beans>

    @Testpublic void test01(){ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");User user = context.getBean("user",User.class);System.out.println(user.name);}

2.属性注入

@Value

    @Componentpublic class User {//@Value("ckl")相当于<property name="name" value="ckl"/> 也可以放在set()上@Value("ckl")public String name;}

3.衍生的注解

@Component有几个衍生注解，我们在web开发中，会按照MVC三层架构分层：

dao ： @Repository

      @Repositorypublic class UserDao {}

service : @Service

      @Servicepublic class UserService {}

controller : @controller

      @Controllerpublic class UserController {}

这四个注解功能一样，都是代表将某个类注册到spring容器中，装配Bean

4.自动装配

@AutoWired：自动装配，通过类型，名字
如果AutoWired不能唯一自动装配上属性，则需要通过@Qualifier(value=“xx”)
@Nullable 字段标记了这个注解，说明这个字段可以为null
@Resource：自动装配，通过名字，类型

5.作用域

    @Component@Scope("singleton")public class User {@Value("ckl")public String name;}

6.小结

xml与注解：

xml更加万能，适用于任何场合,维护简单；
注解不是自己的类不能使用，维护相对复杂

xml与注解的最佳实践：

xml用于管理
注解只负责完成属性的注入
在使用过程中，只需要注意：必须让注解生效，就需要开启注解支持

使用java的方式配置Spring

现在完全不使用Spring的xml配置，全权交给java处理

JavaConfig是Spring的一个子项目，在Spring4之后，成为一个核心功能

实体类：

    public class User {@Value("ckl")private String name;@Overridepublic String toString() {return "User{" +"name='" + name + '\'' +'}';}}

配置文件类

    @Configuration //本身就是一个@Component，@Configuration代表这是一个配置类，就和bean.xml一样//@ComponentScan("com.ckl.pojo")public class MyConfig {//注册一个bean 就相当于 写的一个bean标签//这个方法的返回值相当于 bean标签的class属性@Beanpublic User getUser(){return new User();//返回要注入到bean的对象}}

测试类：

    public class MyTest {@Testpublic void test01(){//如果完全使用了配置类方式去做，就只能通过AnnotationConfig 上下文来获取容器，通过配置类的class对象加载ApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);User user = (User) context.getBean("getUser");//方法名System.out.println(user.toString());}}

这种纯java的配置方式，在springboot中随处可见

代理模式

代理模式分类：静态代理和动态代理

静态代理：

角色分析：

抽象角色：一把会使用接口或者抽象类解决
真实角色：被代理的角色
代理角色：代理真实角色，代理真实角色后，我们一把会做一些附属操作
客户：访问代理对象的人

代码步骤：

1. 接口

       //租房public interface Rent {public void rent();}

2. 真实角色

       //房东public class Host implements Rent{public void rent(){System.out.println("房东要出租房子");}}

3. 代理角色

       //中介public class Proxy implements Rent{private Host host;public Proxy() {}public Proxy(Host host) {this.host = host;}public void rent() {seeHouse();host.rent();hetong();fare();}//看房public void seeHouse(){System.out.println("中介带你看房");}//收中介费public void fare(){System.out.println("收中介费");}//签合同public void hetong(){System.out.println("签合同");}}

4. 客户端访问代理角色

       //租客public class Client {public static void main(String[] args) {//房东要租房子Host host = new Host();//代理,中介棒房东租房子，但需要有一些附属操作[中介费，看房子。。。]Proxy proxy = new Proxy(host);proxy.rent();}}

代理模式好处：

可以使真实角色更加纯粹，不用去关注一些公共的业务
公共交给代理角色，实现了业务的分工
公共业务发生扩展时，方便集中管理

缺点：

一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率变低

加深理解：

接口：

    public interface UserService {public void add();public void delete();public void update();public void query();}

真实对象：

    //真实对象public class UserServiceImpl implements UserService{public void add() {System.out.println("增加一个用户");}public void delete() {System.out.println("删除一个用户");}public void update() {System.out.println("修改一个用户");}public void query() {System.out.println("查询用户");}}

代理对象：

    public class UserServiceProxy implements UserService{private UserServiceImpl userService;public void setUserService(UserServiceImpl userService) {this.userService = userService;}public void add() {log("add()");userService.add();}public void delete() {log("delete()");userService.delete();}public void update() {log("update()");userService.update();}public void query() {log("query()");userService.query();}//添加日志方法public void log(String msg){System.out.println("[Debug] 使用了"+msg+"方法");}}

客户：

    public class Client {public static void main(String[] args) {UserServiceImpl userService = new UserServiceImpl();//userService.add();UserServiceProxy userServiceProxy = new UserServiceProxy();userServiceProxy.setUserService(userService);userServiceProxy.add();userServiceProxy.delete();}}

动态代理：

动态代理和静态代理角色一样
动态代理类是动态生成的，不是我们直接写好的
动态代理分为2大类：基于接口的动态代理、基于类的动态代理
- 基于接口—JDK动态代理[*]
- 基于类—cglib
- java季节吗实现：javasist

需要了解两个类：Proxy:代理 InvocationHandler：调用处理程序

    /*相当于动态代理的工具类*/package com.ckl.demo04;import com.ckl.demo03.Rent;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;//用这个类：自动生成代理类public class ProxyInvocationHandler implements InvocationHandler {//被代理的接口private Object target;public void setTarget(Object target) {this.target = target;}//生成得到代理类public Object getProxy(){return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);}//处理代理实例，并返回结果public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {getLog(method.getName());Object result = method.invoke(target, args);return result;}//附属功能，添加日志public void getLog(String msg){System.out.println("执行了"+msg+"方法");}}public class Client {public static void main(String[] args) {//真实角色UserServiceImpl userService = new UserServiceImpl();//代理角色，一开始并不存在ProxyInvocationHandler pih = new ProxyInvocationHandler();pih.setTarget(userService);//设置要代理的对象//动态生成代理类UserService proxy = (UserService)pih.getProxy();proxy.add();}}

动态代理的好处：

可以使真实角色的操作更加纯粹，不用去关注一些公共的业务
公共业务交给代理角色，实现了业务的分工
公共业务发生扩展时，方便集中管理
一个动态代理类代理的是一个接口，一把就是对应的一类业务
一个动态代理类可以代理多个类，只要是实现了同一个接口即可！

AOP

使用Spring实现AOP

需要导入一个依赖包：

    <dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.2</version></dependency>

方式一：

使用spring的API接口

applicationContext.xml

    <!--    1.注册bean--><bean id="userservice" class="com.ckl.service.UserServiceImpl"/><bean id="beforelog" class="com.ckl.log.BeforeLog"/><bean id="Afterlg" class="com.ckl.log.AfterLog"/><!--    方式1--><!--    2.配置aop  需要导入约束--><aop:config><!--         切入点 : expression(* * * * *):[要执行的位置] --><aop:pointcut id="pointcut" expression="execution(* com.ckl.service.UserServiceImpl.*(..))"/><!--          执行环绕增加           将beforelog这个类切入到pointcut --><aop:advisor advice-ref="beforelog" pointcut-ref="pointcut"/><aop:advisor advice-ref="Afterlg" pointcut-ref="pointcut"/></aop:config>

接口：

    public interface UserService {public void add();public void delete();public void update();public void select();}

真实对象：

    public class UserServiceImpl implements UserService{public void add() {System.out.println("增加用户");}public void delete() {System.out.println("删除用户");}public void update() {System.out.println("修改用户");}public void select() {System.out.println("查询用户");}}

前置

    public class BeforeLog implements MethodBeforeAdvice{//method:要执行的目标对象的方法//objects:参数  o:目标对象public void before(Method method, Object[] objects, Object o) throws Throwable {System.out.println(o.getClass().getName()+"的"+method.getName()+"被执行了");}}

后置

    public class AfterLog implements AfterReturningAdvice {//o:返回值public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {System.out.println("执行了"+method.getName()+"方法，返回结果为："+o);}}

测试

    @Testpublic void Test1(){ApplicationContext con = new ClassPathXmlApplicationContext("applicationContext.xml");//动态代理 代理的是接口//UserServiceImpl userservice = con.getBean("userservice", UserServiceImpl.class);UserService userService = con.getBean("userservice",UserService.class);userService.add();}

方式二：

自定义类来实现AOP[主要是切面定义]

    public class DiyPointCut {public void before(){System.out.println("方法执行前");}public void after(){System.out.println("方法执行后");}}<!--    方式2--><bean id="diy" class="com.ckl.diy.DiyPointCut"/><aop:config><!--        自定义切面  ref：要引入的类--><aop:aspect ref="diy"><!--            切入点--><aop:pointcut id="point" expression="execution(* com.ckl.service.UserServiceImpl.*(..))"/><!--            通知--><aop:before method="before" pointcut-ref="point"/><aop:after method="after" pointcut-ref="point"/></aop:aspect></aop:config>

方式三:

         <bean id="userservice" class="com.ckl.service.UserServiceImpl"/><bean id="beforelog" class="com.ckl.log.BeforeLog"/><bean id="Afterlg" class="com.ckl.log.AfterLog"/><!--        方式三  使用注解--><bean id="annotationPointCut" class="com.ckl.diy.AnnotationPointCut"/><!--    开启注解支持--><aop:aspectj-autoproxy/>

切面：

    @Aspect //标注这个类是一个切面public class AnnotationPointCut {@Before("execution(* com.ckl.service.UserServiceImpl.*(..))")public void before(){System.out.println("方法执行前");}@After("execution(* com.ckl.service.UserServiceImpl.*(..))")public void after(){System.out.println("执行后");}//在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点@Around("execution(* com.ckl.service.UserServiceImpl.*(..))")public void aroud(ProceedingJoinPoint jp) throws Throwable {System.out.println("环绕前：");//System.out.println("***"+jp.getSignature()+"**");;//可以获得签名//执行方法  我们的目标方法Object proceed = jp.proceed();System.out.println("环绕后");}}@Testpublic void Test1(){ApplicationContext con = new ClassPathXmlApplicationContext("applicationContext.xml");//动态代理 代理的是接口//UserServiceImpl userservice = con.getBean("userservice", UserServiceImpl.class);UserService userService = con.getBean("userservice",UserService.class);userService.add();}

整合MyBatis方式一

步骤：

1.导入jar包

junit
mybatis
mysql数据库
spring相关
aop织入
mybatis-spring 【new】

 <?xml version="1.0" encoding="UTF-8"?><project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>org.example</groupId><artifactId>0512_Spring_MyBatis</artifactId><version>1.0-SNAPSHOT</version><dependencies><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.13.2</version><scope>test</scope></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.25</version></dependency><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.5.2</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>5.3.8</version></dependency><!--        spring操作数据库的话还需要一个spring-jdbc包--><dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>5.3.8</version></dependency><dependency><!--            aop织入--><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.2</version></dependency><dependency><!--            spring整合mybatis的包--><groupId>org.mybatis</groupId><artifactId>mybatis-spring</artifactId><version>2.0.2</version></dependency></dependencies></project>

2.编写代码

1.实体类

    public class User {private int id;private String username;private String password;public int getId(){}public void setId(int id){}public String getUsername(){}public void setUsername(String username){}public String getPassword(){}public void setPassword(String password){}public String toString(){}}

2.Mapper映射

    public interface UserMapper {public List<User> selectUser();//一个查询方法}

3.Mapper接口实现类

    public class UserMapperImpl implements UserMapper{//我们的所有操作都使用sqlSession执行，//在之前现在DOI使用sqlSessionTemplatesprivate SqlSessionTemplate sqlSession;public void setSqlSession(SqlSessionTemplate sqlSession){this.sqlSession = sqlSession;}public List<User> selectUser() {UserMapper mapper = sqlSession.getMapper(UserMapper.class);List<User> users = mapper.selectUser();return users;}}

4.Mapper.xml配置文件编写sql语句

    <?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd"><mapper namespace="com.ckl.mapper.UserMapper"><select id="selectUser" resultType="com.ckl.pojo.User">select * from mybatis.test;</select></mapper>

5.在springxml中注入数据源

    <?xml version="1.0" encoding="UTF-8"?><!-- applicationContext.xml --><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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd"><!-- DataSource:使用spring的数据源替换mybatis的配置  c3p0 dbcp druid这里使用spring提供的jdbc--><bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"><property name="driverClassName" value="com.mysql.jdbc.Driver"/><property name="url" value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=UTF-8"/><property name="username" value="root"/><property name="password" value="123456"/></bean><!-- sqlSessionFactory--><bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"><property name="dataSource" ref="datasource"/><!-- 绑定mybatis配置文件--><property name="configLocation" value="classpath:mybatis-config.xml"/><property name="mapperLocations" value="classpath:com/ckl/mapper/*.xml"/><!-- 相当于mybatisxml的注册接口--></bean><!-- SqlSessionTemplate就是我们使用的sqlSession--><bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate"><!-- 只能使用构造器注入sqlSessionFactory，因为源码中没有set()方法--><constructor-arg index="0" ref="sqlSessionFactory"/></bean></beans>

6.在mybatis.xml中编写别名(也可以不写)

    <?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE configurationPUBLIC "-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-config.dtd"><configuration><!--    别名--><typeAliases><package name="com.ckl.pojo"/></typeAliases></configuration>

7.在总的配置文件，applicationContext.xml中注册bean

    <?xml version="1.0" encoding="UTF-8"?><!-- applicationContext.xml --><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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd"><import resource="spring-dao.xml"/><bean id="userMapper" class="com.ckl.mapper.UserMapperImpl"><property name="sqlSession" ref="sqlSession"/></bean></beans>

3.测试

    @Testpublic void test2(){ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");UserMapper userMapper = context.getBean("userMapper",UserMapper.class);for (User user : userMapper.selectUser()) {System.out.println(user);}}

总结：

1.编写数据源配置

2.sqlSessionFactory

3.sqlSessionTemplate

4.需要给接口实现类

5.将实现类注入到spring中

整合MyBatis方式二2

1.导入依赖 2.编写代码

2.1 编写POJO实体类

    public class User {private int id;private String username;private String password;public int getId(){}public void setId(int id){}public String getUsername(){}public void setUsername(String username){}public String getPassword(){}public void setPassword(String password){}public String toString(){}}

2.2 编写Mapper映射接口

    public interface UserMapper {public List<User> selectUser();//一个查询方法}

2.3 编写Mapper映射接口实现类

    public class UserMapperImplTwo extends SqlSessionDaoSupport implements UserMapper{public List<User> selectUser() {//继承SqlSessionDaoSupport类可以直接得到SqlSessionTemplateSqlSession sqlSession = getSqlSession();UserMapper mapper = sqlSession.getMapper(UserMapper.class);return mapper.selectUser();//return getSqlSession().getMapper(UserMapper.class).selectUser();}}

2.4配置Mapper.xml配置

    <?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd"><mapper namespace="com.ckl.mapper.UserMapper"><select id="selectUser" resultType="com.ckl.pojo.User">select * from mybatis.test;</select></mapper>

2.5 编写spring-dao.xml文件

    <?xml version="1.0" encoding="UTF-8"?><!-- applicationContext.xml --><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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd"><!-- DataSource:使用spring的数据源替换mybatis的配置  c3p0 dbcp druid这里使用spring提供的jdbc   数据源也可以在mybatis.xml或applicationContext.xml中配置--><bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"><property name="driverClassName" value="com.mysql.jdbc.Driver"/><property name="url" value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=UTF-8"/><property name="username" value="root"/><property name="password" value="123456"/></bean><!-- sqlSessionFactory--><bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"><property name="dataSource" ref="datasource"/><!-- 绑定mybatis配置文件--><property name="configLocation" value="classpath:mybatis-config.xml"/><property name="mapperLocations" value="classpath:com/ckl/mapper/*.xml"/><!-- 相当于mybatisxml的注册接口--></bean></beans>```##### 2.6 编写mybatis-config.xml文件
```xml<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE configurationPUBLIC "-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-config.dtd"><configuration><!--    别名--><typeAliases><package name="com.ckl.pojo"/></typeAliases></configuration>

2.7 编写 applicationContext.xml文件

每编写一个实体类[Bean对象]，就需要在配置文件中加入

    <?xml version="1.0" encoding="UTF-8"?><!-- applicationContext.xml --><beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><import resource="spring-dao.xml"/><bean id="userMapper" class="com.ckl.mapper.UserMapperImpl"><property name="sqlSession" ref="sqlSession"/></bean><bean id="userMapper2" class="com.ckl.mapper.UserMapperImplTwo"><property name="sqlSessionFactory" ref="sqlSessionFactory"/></bean></beans>

3.测试

    @Testpublic void test3(){ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");UserMapper userMapper = context.getBean("userMapper2",UserMapper.class);for (User user : userMapper.selectUser()) {System.out.println(user);}}

MyBatis

1.编写实体类

    public class User {private int id;private String username;private String password;public int getId(){}public void setId(int id){}public String getUsername(){}public void setUsername(String username){}public String getPassword() {}public void setPassword(String password) {}public String toString() {}}

2.编写核心配置文件

    <?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE configurationPUBLIC "-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-config.dtd"><configuration><!--    别名--><typeAliases><package name="com.ckl.pojo"/></typeAliases><environments default="development"><environment id="development"><transactionManager type="JDBC"/><dataSource type="POOLED"><property name="driver" value="com.mysql.jdbc.Driver"/><property name="url" value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=UTF-8"/><property name="username" value="root"/><property name="password" value="123456"/></dataSource></environment></environments><!--    注册接口--><mappers><mapper class="com.ckl.mapper.UserMapper"/></mappers></configuration>

3.编写接口

    public interface UserMapper {public List<User> selectUser();//一个sql查询的方法}

4.编写Mapper.xml

    <?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd"><mapper namespace="com.ckl.mapper.UserMapper"><!-- 一个查询语句 --><select id="selectUser" resultType="com.ckl.pojo.User">select * from mybatis.test;</select></mapper>

5.测试

    @Testpublic void test1() throws IOException {String resources = "mybatis-config.xml";//加载配置文件InputStream in = Resources.getResourceAsStream(resources);SqlSessionFactory builder = new SqlSessionFactoryBuilder().build(in);SqlSession sqlSession = builder.openSession(true);UserMapper mapper = sqlSession.getMapper(UserMapper.class);List<User> list = mapper.selectUser();for (User user :list) {System.out.println(user);}}

声明式事务

Spring中有声明式事务【AOP】和编程式事务【需要在代码中，进行事务管理】

一组业务，要么都成功，要么都失败
确保完整性和一致性

事务ACID原则

原子性
一致性
隔离性
持久性

开启事务配置

在spring-dao.xml中

    <?xml version="1.0" encoding="UTF-8"?><!-- applicationContext.xml --><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"xmlns:tx="http://www.springframework.org/schema/tx"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsdhttp://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx.xsd"><!-- 配置声明式事务--><bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><constructor-arg ref="datasource" /></bean><!-- 结合AOP 实现事务的织入--><!-- 配置事务通知--><tx:advice id="txAdvice" transaction-manager="transactionManager"><!-- 给哪些方法配置事务--><!-- parpagation 配置事务的传播特性[7种] REQUIRED:默认--><tx:attributes><tx:method name="add" propagation="REQUIRED"/><tx:method name="delete" propagation="REQUIRED"/><tx:method name="*" propagation="REQUIRED"/></tx:attributes></tx:advice><!-- 配置事务的切入点--><aop:config><aop:pointcut id="txPointCut" expression="execution(* com.ckl.mapper.*.*(..))"/><aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/></aop:config></beans>

为什么需要事务

不配置事务，可能存在数据提交不一致的情况
如果我们不在Spring中去配置声明式事务，我们就需要在代码中手动配置事务
事务在项目的开发中非常重要，涉及到数据的一致性和完整性问题