springDataJPA和mybatis的整合 之springdata编写sql的5种方式

    Jpa实现数据库的CRUD

需求     使用SpringDataJpa实现数据库的CRUD

开发步骤

?    1    创建MAVEN 工程

?    2    添加依赖

?            mysql

?            c3p0

?            hibernate

?            springDataJpA

?            spring相关jar包

?    3 创建配置文件

?    4 创建实体类

?    5 创建Dao  创建接口 即可  要求接口继承  JpaRspository接口

?    6 编写测试程序

?        1 初始花啊spring  容器

?        2 从容器中获得Dao代理对象

?        3 使用Dao  实现增删改查

?    添加/修改 数据  save

?    删除数据    delete

?         查询    ：findOne.

?    查询全部   findAll()

?            findAll(Pageable pageaable)     返回Page对象      这里面包含：totalElements  总记录数

?                                                                     totalPages     总页数

?                                                                    content   结果列表

?         
## 1 springDataJpa  其它的相关查询方式

?    1 查询全部带排序‘

?    2  count  统计

?    3 exixtx  判断记录是否存在

## 2 在springDataJpa框架使用Jpql 查询

?      使用方法 

?        a:   在dao 接口中定义一个方法  使用方法的参数设置jpql的参数   并且使用方法的返回值接受查询的结果

?        b: 在方法上添加一个注解Qquery

?        c 在注解中编写jpql

?        d 测试

## 3 使用原生的Sql语句

?    使用方法

?          1  dao中  定义一个方法

?           2  在方法中添加@Query注解

?          3 在注解中 添加 原生的sql 语句   添加一个属性  nativeQuery=true

?          4 测试

## 4 方法命名规则查询

?    通过一定的规则 定义一个方法  框架本省就可以根据方法名生成一个SQL语句进行查询

?        规则

?            1 应该使用findBy开头

?            2 查询某个字段  findBy后跟实体类的属性的名称  

?            3 如果有多个条件   就在方法后加And+实体类的属性名

?            4  方法的参数 对应查询的定义

?            5 返回值根据返回的数据类型定义

   如果需要分页查询   在方法中添加一个参数Pageable 即可

## 5 使用Specification方式进行查询

   最强大的查询方式  除了原生的SQL 语句以外   最复杂的查询方式

使用方式

?    1 要在dao 继承JpaSeciFicationExection 接口

?    2 使用JpaSeciFicationExection 接口 中提供的方法进行查询

?        每个方法都需要使用Specification对象作为参数
   CRUD  

?      框架整合

?        （数据源）（工程类对象）（事物）(dao 扫描器)

?    Entity

?    Dao

?       定义接口就行  继承JpaRepository<Customer,Long>

1  crud

?     使用dao 实现CRUD（重点）

?     添加 save

?     修改  save

?      删除  delete

?    查询   findOne    getOne   findAll  可以分页  排序

2 使用jpql 查询

?     查询 @Query    更新   删除   

3 原生 sql 

?    使用@Query注解  添加属性nativeQuery=true

4 方法名命名规则 查询（重点）  findBy

5 使用SpeciFication  方式查询
dao层

public interface CustomerDao extends JpaRepository<Customer,Long>, JpaSpecificationExecutor<Customer> {
    @Query("from Customer")
    List<Customer> getAllCustomer();
    @Query("from Customer")
    List<Customer> getAllCustomerByPape(Pageable pageable);
    // 条件查询‘
    @Query("from Customer where cust_id=?")
    Customer getCustomerById(long id);
    // 模糊查询
    @Query("from Customer where custName like?2 and custAddress like ?1")
    List<Customer> getCustList(String address,String name);
   // 更新
    @Query("update Customer set custSource=? where custId=?")
   @Modifying
//    @Transactional
    void updateSource(String source,long id);
    // 原生语句调价查询操作
    @Query(value = "SELECT  * FROM cst_customer where cust_name LIKE ?",nativeQuery = true)
    List<Customer> getCustomerListByNative(String name);

    //方法命名规则查询
    Customer findByCustId(long id);

    List<Customer> findByCustNameLikeAndCustAddressLike(String name,String address);
    // 分页
    Page<Customer> findByCustAddressLike(String address,Pageable pageable);
}

测试层


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class JpaCRUD1 {
    @Autowired
    private CustomerDao customerDao;
    @Test
    public void addCustomer(){
//        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
//        CustomerDao customerDao = ac.getBean(CustomerDao.class);
        Customer cc = new Customer();
        cc.setCustName("谢大脚");
        cc.setCustAddress("北京朝阳区");
        cc.setCustLevel("黑金VIP");
        customerDao.save(cc);
    }
    // 删除
    @Test
    public void deleteCustomer(){
        customerDao.delete(2l);
    }
    // 更新数据
    @Test
    public void updateCustomer(){
        Customer customer = customerDao.findOne(1l);
        customer.setCustName("张一山");
        customer.setCustLevel("铂金vip");
        customerDao.save(customer);

    }
    @Test
    public  void findById(){
        Customer one = customerDao.findOne(1l);
        System.out.println(one);
    }
    @Test
    @Transactional// 加上事物注解   在方法执行结束之前   连接不会断
    public  void testGetOne(){
        Customer one = customerDao.getOne(1l);
        System.out.println("-----------------------");
        System.out.println(one);
    }
    @Test
    public void testFindAll(){
        List<Customer> customerDaoAll = customerDao.findAll();
        for(Customer customer:customerDaoAll){
            System.out.println(customer);
        }

    }
    @Test
    public void testFindAllWithPage() {
        PageRequest pageRequest = new PageRequest(0, 2);
        Page<Customer> page = customerDao.findAll(pageRequest);
        long totalElements = page.getTotalElements();
        System.out.println("总记录数"+totalElements);
        int totalPages = page.getTotalPages();
        System.out.println("总页码"+totalPages);
        List<Customer> content = page.getContent();
        for(Customer customer:content){
            System.out.println(customer);
        }
    }
    //  查询所有带排序  8月19日
    @Test
    public void testFindAllWithSort(){
        // 创建一个sort  对象
        //  参数1  排序方式
        // 参数2  排序的字段  应该是实体类的属性名
        Sort sort = new Sort(Sort.Direction.DESC,"custId");
        List<Customer> list = customerDao.findAll(sort);
        for(Customer customer:list){
            System.out.println(customer);
        }
    }
    @Test
    public void testCount(){
        long count = customerDao.count();
        System.out.println(count);
    }
    @Test
    public void testExists(){
        boolean exists = customerDao.exists(2l);
        System.out.println(exists);
    }
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class JPQLCrud {
    @Autowired
    private CustomerDao customerDao;
    @Test
    public void testgetAllCustomer(){
        List<Customer> list = customerDao.getAllCustomer();
        for(Customer customer:list){
            System.out.println(customer);
        }
    }
    @Test
    public void testGetAllCustomerByPage(){
        List<Customer> allCustomerByPape = customerDao.getAllCustomerByPape(new PageRequest(0, 3));
      for(Customer customer:allCustomerByPape){
          System.out.println(customer);
      }
    }
    @Test
    public void testGetCustomerById(){
        Customer customerById = customerDao.getCustomerById(1l);
        System.out.println(customerById);
    }
    @Test
    public void testGetCustList(){
        List<Customer> custList = customerDao.getCustList("%北京%", "%大%");
        for(Customer customer:custList){
            System.out.println(customer);
        }
    }
    @Test
    @Transactional
    @Commit
    public void testUpdatSource(){
      customerDao.updateSource("互联网111",1l);
    }
    @Test

    public void testCustomerListByNative(){
        List<Customer> list = customerDao.getCustomerListByNative("%脚%");
        for(Customer customer :list){
            System.out.println(customer);
        }
    }
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringDataJpaVoid {
    @Autowired
    private CustomerDao customerDao;
    @Test
    public void testFindByCustId(){
        Customer customer = customerDao.findByCustId(1l);
        System.out.println(customer);
    }
    @Test
    public void testFindByCustNameLikeAndCustAddressLike(){
        List<Customer> list = customerDao.findByCustNameLikeAndCustAddressLike("%脚%", "%北京%");
        for(Customer customer:list){
            System.out.println(customer);
        }
    }
    @Test
    public void testFindByCustomerAddressByPage(){
        Page<Customer> pa = customerDao.findByCustAddressLike("%北京%", new PageRequest(0, 3));
        System.out.println(pa.getTotalElements());
        System.out.println(pa.getTotalPages());
        List<Customer> list = pa.getContent();
        for(Customer customer:list){
            System.out.println(customer);
        }
        // 测试 使用Specification方式进行查询

    }
    @Test
    public void testFindByIdSpeciFication(){
        Customer customer =customerDao.findOne(new Specification<Customer>() {
            @Override
            public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
               //  参数1  字段名称
                // 参数2    字段的值
                Predicate predicate = criteriaBuilder.equal(root.get("custId"), 1l);
                return predicate;
            }
        });
        System.out.println(customer);
    }
    //  根据地址模糊查询
    @Test
    public void testFindByNmaeAdress(){
        customerDao.findAll(new Specification<Customer>() {
            @Override
            public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
               // 创建 根据模糊查询的条件
                Predicate predicate1 = criteriaBuilder.like(root.get("custName"), "%脚%");

                Predicate like1 = criteriaBuilder.like(root.get("custAddress"), "%北京%");
                // 组合两个条件
                Predicate predicate = criteriaBuilder.and(predicate1, like1);
                return predicate;
            }
        }).forEach(c->System.out.println(c));//forEach(System.out::println);
    }
    @Test
    public void testFindByNmaeAdressWithPage(){
        Page<Customer> page = customerDao.findAll(new Specification<Customer>() {
            @Override
            public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                // 创建 根据模糊查询的条件
                Predicate predicate1 = criteriaBuilder.like(root.get("custName"), "%脚%");

                Predicate like1 = criteriaBuilder.like(root.get("custAddress"), "%北京%");
                // 组合两个条件
                Predicate predicate = criteriaBuilder.and(predicate1, like1);
                return predicate;
            }
        },new PageRequest(0,3));
        System.out.println(page.getTotalElements());
        System.out.println(page.getTotalPages());
        List<Customer> content = page.getContent();
        for (Customer customer:content){
            System.out.println(customer);
        }
    }
}

https://www.cnblogs.com/dragonyl/p/11364046.html

原文地址：https://www.cnblogs.com/dragonyl/p/11378844.html

时间： 2024-08-22 19:26:23

springDataJPA和mybatis的整合 之springdata编写sql的5种方式的相关文章

为Node.js编写组件的几种方式

本文主要备忘为Node.js编写组件的三种实现:纯js实现.v8 API实现(同步&异步).借助swig框架实现. 关键字:Node.js.C++.v8.swig.异步.回调. 简介 首先介绍使用v8 API跟使用swig框架的不同: (1)v8 API方式为官方提供的原生方法,功能强大而完善,缺点是需要熟悉v8 API,编写起来比较麻烦,是js强相关的,不容易支持其它脚本语言. (2)swig为第三方支持,一个强大的组件开发工具,支持为python.lua.js等多种常见脚本语言生成C++组件

多线程 编写多线程的两种方式

1.通过继承Thread编写多线程类 1 package org.zln.thread; 2 3 import java.util.Date; 4 5 /** 6 * Created by coolkid on 2015/6/21 0021. 7 */ 8 public class TestThread extends Thread{ 9 private int time;//休眠时间 10 private String user;//调用用户 11 12 public TestThread(i

控件注册监听器编写响应的三种方式

以注册一个Button的click事件为例 方法①:通过内部类(匿名类)的方法 public class MainActivity extends Activity {    Button btn_01;  //声明Button    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R

@Param注解在mybatis中的使用以及传入参数的几种方式（转）

第一种: Dao层的方法 <span style="font-size:12px;">Public User selectUser(String name,String password);</span> 对应的Mapper.xm <select id="selectUser" resultMap="BaseResultMap"> select * from user_user_t where user_nam

记录初学Spring boot中使用GraphQL编写API的几种方式

Spring boot+graphql 一.使用graphql-java-tools方式 <dependency> <groupId>com.graphql-java-kickstart</groupId> <artifactId>graphql-java-tools</artifactId> <version>5.6.0</version> </dependency> <dependency> &

SSM框架Spring+SpringMVC+MyBatis——详细整合教程

摘要: 包括SQL Maps和Data Access ObjectsDAOMyBatis 消除了几乎所有的JDBC代码和参数的手工设置以及结果集的... 摘要:   spring MVC属于SpringFrameWork的后续产品已经融合在Spring Web Flow里面.Spring MVC 分离了控制器.模型对... 1.基本概念 1.1.Spring Spring是一个开源框架Spring是于2003 年兴起的一个轻量级的Java 开发框架由Rod Johnson 在其著作Expert 

Maven项目管理:SpringMVC+Mybatis+Velocity整合笔记

Maven创建项目 略…具体过程可参考用Maven创建第一个web项目 配置Spring MVC 导入Spring MVC 需要的包在pom.xml 文件下加入: 123456789101112 <!-- spring mvc begin --><dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <v

redis mybatis spring整合

最近想在框架里面加入redis,替换原因呢其实也没有,就是单纯的想替换掉 ---维基百科:redis介绍 一般开发中用户状态使用session或者cookie,两种方式各种利弊. Session:在InProc模式下容易丢失,并且引起并发问题.如果使用SQLServer或者SQLServer模式又消耗了性能 Cookie则容易将一些用户信息暴露,加解密同样也消耗了性能. Redis采用这样的方案解决了几个问题, 1.Redis存取速度快. 2.用户数据不容易丢失. 3.用户多的情况下容易支持集群

基于maven进行spring 和mybatis的整合（Myeclpise）

学习日记:基于maven进行spring和mybatis的整合,进行分页查询 什么是maven:maven是一个项目管理工具,使用maven可以自动管理java项目的整个生命周期,包括编译.构建.测试.发布和报告等.在大型项目开发中,使用maven来管理是必不可少的. 开发工具myeclipse:myclipse 10.0自带了maven的插件.也可以网上下载maven插件 1.新建一个maven project,点击next,选择maven-archetype-webapp,点击next,填写