mybatis注解开发_mybatis的分页插件_Spring框架入门

最新推荐文章于 2023-05-10 16:29:57 发布

洛柒。

最新推荐文章于 2023-05-10 16:29:57 发布

阅读量295

点赞数

文章标签： mybatis spring java

洛柒

本文链接：https://blog.csdn.net/qq_53972833/article/details/127312252

版权

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)

   <!--mybatis分页插件-->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.1.10</version>
        </dependency>

2） mybatis的核心文件配置参数：—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<T>
        //----->提供了方法： public static <T> PageInfo<T> of(List<T> 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中<bean id="xxxx">
        //1)解析beans.xml
        //使用dom4j里面解析器SAXReader
        SAXReader reader = new SAXReader();
        InputStream inputStream = MyBeansFactory.class.getClassLoader().getResourceAsStream("beans.xml");
        try {
            //获取到文档对象Document代表整个 beans.xml文件
            Document document = reader.read(inputStream);
            //通过文档对象获取根标签对象 beans的标签对象
            Element rootElement = document.getRootElement();
            //利用xpath技术 快速定位某个标签    (使用xpath表达)
            //通过节点获取子节点标签对象---bean标签对象
            // //bean:不分层级关系选中所有的bean标签
            // [] :xxxx的标签
            // @id: 带有id属性的
//       //bean[@id='"+beanId+"']  选取带有id属性并且它的内容是beanId的bean标签
            Element beanElement = (Element) rootElement.
                    selectSingleNode("//bean[@id='" + id + "']");//获取指定的子节点对象
            //通过beanElement 的bean标签对象 获取class属性值
            String aClass = beanElement.attributeValue("class");
            System.out.println(aClass);//"com.qf.service.impl.UserServiceImpl"

            //之前的servlet又需要通过服务器读取配置文件
            //servlet

            //servlet-name
            //servlet-class
            //serlvet-mapping
            //servlet-name
            //url-pattern

            //反射
            Class clazz = Class.forName(aClass);
            //接口实现类中:没有提供任何构造方法,系统无参
            //直接创建当期类实例
            Object obj = clazz.newInstance();

            return obj ;
        } catch (DocumentException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

        return null;
    }

    public static void main(String[] args) {
        Object userService = MyBeansFactory.getBean("userService");
        System.out.println(userService);
    }

}

其中需要导入dom4j的插件 ---- jaxen

<!--dom4j插件

       xpath 快速查询并定位xml文件到某个标签
        jaxen xx.jar
        -->
        <dependency>
            <groupId>jaxen</groupId>
            <artifactId>jaxen</artifactId>
            <version>1.1.6</version>
        </dependency>

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包)

<!--Spring核心jar包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>

2. spring的核心配置文件

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