mybatis注解开发_mybatis的分页插件_Spring框架入门
1. MyBatis注解开发
import org.apache.ibatis.annotations.*;
@Select
@Update
@Insert
@Delete
配置映射关系：@Results ----可配置多个@Result
单表CRUD:
package com.lty.mapper;
import com.lty.pojo.User;
import org.apache.ibatis.annotations.*;
import java.util.List;
public interface UserMapper {
//@Results相当于ResultMap
@Results(id = "userMap",value = {
//id默认值为false ----true:主键
@Result(id = true,property = "id",column = "id"),
@Result(property = "userName",column = "username"),
@Result(property = "birthday",column = "birthday"),
@Result(property = "address",column = "address"),
})
/**
* 查询所有
*/
@Select("select * from my_user")
List<User> getAll();
/**
* 根据id查询
* @param id
* @return
*/
@ResultMap("userMap")
@Select("select * from my_user where id=#{id}")
User getById(int id);
/**
* 修改
* @param user
* @return
*/
@ResultMap("userMap")
@Update("update my_user set username=#{userName},address=#{address} where id=#{id}")
int updateUser(User user);
/**
* 添加
* @param user
* @return
*/
@ResultMap("userMap")
@Insert("insert into my_user(username,birthday,address) values (#{userName},#{birthday},#{address})")
int save(User user);
/**
* 删除
* @param id
* @return
*/
@ResultMap("userMap")
@Delete("delete from my_user where id=#{id}")
int del(int id);
/**
* 模糊查询
* @param name
* @return
*
* ${}:字符串拼接符号 不推荐
* #{}:推荐占位符号
* @Select("select * from my_user where username like #{name}")
*/
@ResultMap("userMap")
@Select("select * from my_user where username like %${name}%")
List<User> selectByName(String name);
}
一对一关系：需要用到@One()
//一个账户对应一个用户
package com.lty.mapper;
import com.lty.pojo.Account;
import org.apache.ibatis.annotations.*;
import org.apache.ibatis.mapping.FetchType;
import java.util.List;
public interface AccountMapper {
//id唯一标识此Results(相当于ResultMap)
@Results(id = "AccountMap",value = {
//开启主键
@Result(id = true, property = "id", column = "aid"),
@Result(property = "money", column = "money"),
@Result(property = "uid", column = "uid"),
@Result(property = "user", column = "uid",
// //配置一对一的关系 配置加载模式
//@one--->fetchType---返回值枚举: lazy 懒加载 EAGER立即加载
one=@One(select = "com.lty.mapper.UserMapper.getById",fetchType = FetchType.EAGER))
})
/**
* 根据一个账户对应一个用户，查询所有
*/
@Select("select a.id as aid,a.money,a.uid,u.* from my_account a left join my_user u on a.uid=u.id ")
List<Account> getAll();
//除了第一个方法，其余都需加入 @ResultMap("AccountMap") 注解
}
UserTest:
import com.lty.mapper.UserMapper;
import com.lty.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.Date;
import java.util.List;
public class UserTest {
private SqlSession session = null;
private UserMapper mapper = null;
@Before
public void init() {
try {
InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
session = factory.openSession();
/*jdk动态代理*/
mapper = session.getMapper(UserMapper.class);
} catch (IOException e) {
e.printStackTrace();
}
}
@After
public void CommitAndClose() {
session.commit();
if (session != null) {
session.close();
/*以便垃圾回收器回收*/
session = null;
}
}
@Test
public void testGetAll() {
List<User> all = mapper.getAll();
for (User user : all) {
System.out.println(user);
}
}
@Test
public void testById() {
User u = mapper.getById(1);
System.out.println(u);
}
@Test
public void testUpdate() {
User user = new User();
user.setId(3);
user.setUserName("李四");
user.setAddress("山东");
int i = mapper.updateUser(user);
System.out.println(i > 0 ? "success" : "false");
}
@Test
public void save() {
User user = new User();
user.setId(3);
user.setBirthday(new Date());
user.setUserName("张三");
user.setAddress("长江流域");
int i = mapper.save(user);
System.out.println(i > 0 ? "success" : "false");
}
@Test
public void delete() {
int i = mapper.del(17);
System.out.println(i > 0 ? "success" : "false");
}
@Test
public void SelectLike() {
List<User> list = mapper.selectByName("张");
for (User user : list) {
System.out.println(user);
}
}
}
AccountTest:
import com.lty.mapper.AccountMapper;
import com.lty.pojo.Account;
import com.lty.util.MyBatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import java.util.List;
public class AccountTest {
SqlSession sqlSession = MyBatisUtil.getSqlSession();
AccountMapper mapper = MyBatisUtil.getMapper(AccountMapper.class);
@Test
public void getAllAccount(){
List<Account> all = mapper.getAll();
for (Account account : all) {
System.out.println(account);
}
}
}
一对多关系：
public interface UserMapper {
/**
* @Select(value="sql语句") 只是给value赋值, 可以省略value
*
*如果实体的类属性名称和表的字段不对应,
* 定义一个注解@Results--指定id属性---类似于xml配置里面定义ResultMap 指定id
* 指定value属性--->@Result[] 数组--->可以配置实体的属性名称和字段一一对应
* 查询所有用户
* @return 返回用户列表
*/
//@Results相当于ResultMap
@Results(id = "userMap", value = {
//id默认值为false ----true:主键
@Result(id = true, property = "id", column = "id"),
@Result(property = "userName", column = "username"),
@Result(property = "birthday", column = "birthday"),
@Result(property = "address", column = "address"),
//配置一对多的映射关系
//property:包含多的一个实体属性名称
//column:账户表的uid和用户表id一致
//many属性:返回值@Many注解配置多的一方
@Result(property = "accounts", column = "id",
//开启懒加载
many = @Many(select = "com.lty.mapper.AccountMapper.findAccountById",
fetchType = FetchType.LAZY))
})
/**
* 查询所有
*/
@Select("select * from my_user u left join my_account a on u.id=a.id")
List<User> getAll();
}
结果
2. MyBatis的分页插件
步骤：
- 1） 导入jar包（pagehelper)
<dependency>
<groupId>com.github.pagehelpergroupId>
<artifactId>pagehelperartifactId>
<version>5.1.10version>
dependency>
- 2） mybatis的核心文件配置参数：—MyBatis 允许你在映射语句执行过程中的某一点进行拦截调用
在映射文件执行到某一点进行拦截调用
<plugins>
<plugin interceptor="com.github.pagehelper.PageInterceptor">plugin>
plugins>
- 3）代码实现----依然进行普通的查询所有方法，让分页拦截器拦截调用
/**
* 通过mybatis的分页插件进行分页查询
*/
@Test
public void getByPageHelper() {
//设置分页条件
//PageHelper提供了一个静态的代码 startPage(int pageNum, int pageSize)
//参数： 当前页，每页条数
PageHelper.startPage(1,2);//每页显示的条件
List<User> all = mapper.getAll();
//查看分页的详细信息 PageInfo PageInfo of(List list) {
// return new PageInfo(list);
// }
PageInfo<User> userPageInfo = PageInfo.of(all);//查询到分页数据存到userPageInfo
System.out.println(userPageInfo);
}
3.Spring——开源的框架
使现有技术更容易使用，整合了所有的框架
有点：开源免费、轻量级、非侵入式、IoC(控制反转—不用new对象，底层使用反射实现)，Aop(面向切面编程)，支持事务(原子性、一致性、隔离性、持久性)处理,对框架整合支持
SHH=Spring+struct2+hibernate
SSM=Spring+SpringMVC+MyBatis
- 引入Spring
上图中我们可以看到，传统的UserService us=new UserServiceImpl()方式耦合度较高，我们追求低耦合！！
为了降低耦合度提供简单工厂模式操作，
步骤：
1. 准备beans.xml文件
<?xml version="1.0" encoding="UTF-8" ?>
<beans>
<!--自定义配置我的相关的业务接口以及dao层的接口对应的实现类信息等等
id代表的bean标签的唯一标识(bean标签:描述接口对象)
class:接口对应的实现类的全限定名称
dom for java
通过一种技术:dom4j(基于面向对象) 可以读取xml文件 通过解析器SAXReader
将xml文件中的每一个标签封装对象, 通过id属性名称 找到并获取bean标签对象 ,获取它的class属性的内容
获取到了接口对应的实现类的全限定名称!
-->
<bean id="userService" class="com.qf.service.impl.UserServiceImpl"></bean>
<bean id="accountService" class="com.qf.service.impl.AcountServiceImpl"></bean>
<!--....一堆bean-->
</beans>
2. 自定义工厂类，使用静态方法工厂模式完成对xml文件的解析以及创建接口对象(实现类的全限定名称可以直接创建实例)
package com.lty.factory;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import java.io.InputStream;
/**
* 自定义工厂类：静态工厂类解析xml文件，并且获取接口的实现类对象
*/
public class MyBeansFactory {
//提供私有的构造方法
private MyBeansFactory() {
}
//对外提供公共的静态访问方法
public static Object getBean(String id) {//传入的参数为beans.xml中其中需要导入dom4j的插件 ---- jaxen
jaxen
jaxen
1.1.6
3. 编写测试类：
import com.lty.factory.MyBeansFactory;
import com.lty.service.UserService;
import org.junit.Test;
public class testFactory {
@Test
public void getAllUser(){
UserService bean = (UserService) MyBeansFactory.getBean("userService");
String msg = bean.getMsg(2);
System.out.println(msg);
}
}
结果：
4. Spring方式（步骤）：
1. 导入jar包：Spring-context(Spring核心jar包)
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-contextartifactId>
<version>5.2.10.RELEASEversion>
dependency>
2. spring的核心配置文件
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="userService" class="com.lty.service.impl.UserServiceImpl"/>
beans>
3. 编写测试类：
步骤：
- 创建spring容器（读取核心配置文件）
- 获取实现类对象——spring内置工厂模式完成
- 调用实现类的方法
import com.lty.service.impl.UserServiceImpl;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class testSpring {
@Test
public void tstSPring(){
//创建容器，读取配置文件
ApplicationContext ac=new ClassPathXmlApplicationContext("spring-config.xml");
//获取接口类的实现类
UserServiceImpl service = ac.getBean("userService", UserServiceImpl.class);
//调用实现类的方法
String msg = service.getMsg(2);
System.out.println(msg);
}
结果：
