程序学者
程序学者

JAVA框架08 -- Spring Data JPA

Spring Data JPA

Spring Data JPA概述

  • Spring Data JPA 让我们解脱了DAO层的操作，基本上所有CRUD都可以依赖于它来实现,在实际的工作工程中，推荐使用Spring Data JPA + ORM（如：hibernate）完成操作，这样在切换不同的ORM框架时提供了极大的方便，同时也使数据库层操作更加简单，方便解耦

Spring Data JPA的特性

  • SpringData Jpa 极大简化了数据库访问层代码。 如何简化的呢？ 使用了SpringDataJpa，我们的dao层中只需要写接口，就自动具有了增删改查、分页查询等方法。

Spring Data JPA 与 JPA和hibernate之间的关系

  • JPA是一套规范，内部是有接口和抽象类组成的。hibernate是一套成熟的ORM框架，而且Hibernate实现了JPA规范，所以也可以称hibernate为JPA的一种实现方式，我们使用JPA的API编程，意味着站在更高的角度上看待问题（面向接口编程）
  • Spring Data JPA是Spring提供的一套对JPA操作更加高级的封装，是在JPA规范下的专门用来进行数据持久化的解决方案。

Spring Data JPA的快速入门

需求

  • Spring Data JPA完成客户的基本CRUD操作

搭建Spring Data JPA的开发环境

引入Spring Data JPA的坐标

  • 使用Spring Data JPA，需要整合Spring与Spring Data JPA，并且需要提供JPA的服务提供者hibernate，所以需要导入spring相关坐标，hibernate坐标，数据库驱动坐标等

整合Spring Data JPA与Spring

  • applicationContext.xml



"entityManagerFactoty" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
    "dataSource" ref="dataSource" />
    
    "packagesToScan" value="cn.itcast.domain" />
    
    "persistenceProvider">
        class="org.hibernate.jpa.HibernatePersistenceProvider"/>
    

    
    "jpaVendorAdapter">
        class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
            
            "generateDdl" value="false" />
            
            "database" value="MYSQL" />
            
            "databasePlatform" value="org.hibernate.dialect.MySQLDialect" />
            
            "showSql" value="true" />
        
    

    
    "jpaDialect" >
        class="org.springframework.orm.jpa.vendor.HibernateJpaDialect" />
    




"dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    
    
    
    



package="cn.itcast.dao" transaction-manager-ref="transactionManager"
               entity-manager-factory-ref="entityManagerFactoty" >


"transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
    



"txAdvice" transaction-manager="transactionManager">
    
        "save*" propagation="REQUIRED"/>
        "insert*" propagation="REQUIRED"/>
        "update*" propagation="REQUIRED"/>
        "delete*" propagation="REQUIRED"/>
        "get*" read-only="true"/>
        "find*" read-only="true"/>
        "*" propagation="REQUIRED"/>
    




    "pointcut" expression="execution(* cn.itcast.service.*.*(..))" />
    "txAdvice" pointcut-ref="pointcut" />







使用JPA注解配置映射关系(编写一个实体类使用注解)

  • 所有注解使用jpa的规范提供的注解（都在javax下的引用）

使用Spring Data JPA完成需求

编写符合Spring Data JPA规范的Dao层接口

  • Spring Data JPA是spring提供的一款对于数据访问层（Dao层）的框架，使用Spring Data JPA，只需要按照框架的规范提供dao接口，不需要实现类就可以完成数据库的增删改查、分页查询等方法的定义，极大的简化了我们的开发过程
  • 在Spring Data JPA中，对于定义符合规范的Dao层接口，我们只需要遵循以下几点就可以了：
    1. 创建一个Dao层接口，并实现JpaRepository和JpaSpecificationExecutor
    2. 提供相应的泛型
package cn.itcast.dao;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import cn.itcast.entity.Customer;
/**
 * JpaRepository<实体类类型，主键类型>：用来完成基本CRUD操作
 * JpaSpecificationExecutor<实体类类型>：用于复杂查询（分页等查询操作）
 */
public interface CustomerDao extends JpaRepository<Customer, Long>, JpaSpecificationExecutor<Customer> {
}

完成基本CRUD操作

方法

  • findOne（id） ：根据id查询
  • save(customer):保存或者更新（依据：传递的实体类对象中，是否包含id属性）
  • delete（id） ：根据id删除
  • findAll() : 查询全部

使用

  • 完成了Spring Data JPA的环境搭建，并且编写了符合Spring Data JPA 规范的Dao层接口之后，就可以使用定义好的Dao层接口进行客户的基本CRUD操作
@RunWith(SpringJUnit4ClassRunner.class). //声明spring提供的单元测试环境
@ContextConfiguration(locations="classpath:applicationContext.xml") //指定spring容器的配置信息
public class CustomerDaoTest {

    @Autowired
    private CustomerDao customerDao;
    
    /**
     * 保存客户：调用save(obj)方法
     */
    @Test
    public void testSave() {
        Customer c = new Customer();
        c.setCustName("传智");
        customerDao.save(c);
    }
    
    /**
     * 修改客户：调用save(obj)方法
     *      对于save方法的解释：如果执行此方法是对象中存在id属性，即为更新操作会先根据id查询，再更新    
     *                      如果执行此方法中对象中不存在id属性，即为保存操作
     *          
     */
    @Test
    public void testUpdate() {
        //根据id查询id为1的客户
        Customer customer = customerDao.findOne(1l);
        //修改客户名称
        customer.setCustName("aa");
        //更新
        customerDao.save(customer);
    }
    
    /**
     * 根据id删除：调用delete(id)方法
     */
    @Test
    public void testDelete() {
        customerDao.delete(1l);
    }
    
    /**
     * 根据id从数据库查询
     *      @Transactional : 保证getOne正常运行
     *
     *  findOne：
     *      em.find()           :立即加载
     *  getOne：
     *      em.getReference     :延迟加载
     *      * 返回的是一个客户的动态代理对象
     *      * 什么时候用，什么时候查询
     */
    @Test
    @Transactional
    public void  testGetOne() {
        Customer customer = customerDao.getOne(4l);
        System.out.println(customer);
    }
    
    /**
     * 查询所有
     */
    @Test
    public void testFindAll() {
        List list = customerDao.findAll();
        for(Customer customer : list) {
            System.out.println(customer);
        }
    }

    /**
     * 测试统计查询：查询客户的总数量
     *      count:统计总条数
     */
    @Test
    public void testCount() {
        long count = customerDao.count();//查询全部的客户数量
        System.out.println(count);
    }

    /**
     * 测试：判断id为4的客户是否存在
     *      1. 可以查询以下id为4的客户
     *          如果值为空，代表不存在，如果不为空，代表存在
     *      2. 判断数据库中id为4的客户的数量
     *          如果数量为0，代表不存在，如果大于0，代表存在
     */
    @Test
    public void  testExists() {
        boolean exists = customerDao.exists(4l);
        System.out.println("id为4的客户 是否存在："+exists);
    }
}

springDataJpa的运行过程和原理剖析

  1. 通过JdkDynamicAopProxy的invoke方法创建了一个动态代理对象
  2. SimpleJpaRepository当中封装了JPA的操作（借助JPA的api完成数据库的CRUD）
  3. 通过hibernate完成数据库操作（封装了jdbc）

复杂查询

借助接口中的定义好的方法完成查询

  • 在继承JpaRepository，和JpaRepository接口后,我们就可以使用接口中定义的方法进行查询

继承JpaRepository后的方法列表

继承JpaSpecificationExecutor的方法列表

jpql的查询方式

  • 使用Spring Data JPA提供的查询方法已经可以解决大部分的应用场景，但是对于某些业务来说，我们还需要灵活的构造查询条件，这时就可以使用@Query注解，结合JPQL的语句方式完成查询
  • @Query 注解的使用非常简单，只需在方法上面标注该注解，同时提供一个JPQL查询语句即可
public interface CustomerDao extends JpaRepository<Customer, Long>,JpaSpecificationExecutor<Customer> {    
    //@Query 使用jpql的方式查询。
    @Query(value="from Customer")
    public List findAllCustomer();
    
    //@Query 使用jpql的方式查询。?1代表参数的占位符，其中1对应方法中的参数索引
    @Query(value="from Customer where custName = ?1")
    public Customer findCustomer(String custName);
}
  • 此外，也可以通过使用 @Query 来执行一个更新操作，为此，我们需要在使用 @Query 的同时，用 @Modifying 来将该操作标识为修改查询，这样框架最终会生成一个更新的操作，而非查询
@Query(value="update Customer set custName = ?1 where custId = ?2")
@Modifying
 public void updateCustomer(String custName,Long custId);"

使用SQL语句查询

/**
 * nativeQuery : 使用本地sql的方式查询
 */
@Query(value="select * from cst_customer",nativeQuery=true)
public void findSql();

方法命名规则查询

  • 方法命名规则查询就是根据方法的名字，就能创建查询。只需要按照Spring Data JPA提供的方法命名规则定义方法的名称，就可以完成查询工作。Spring Data JPA在程序执行的时候会根据方法名称进行解析，并自动生成查询语句进行查询
  • 按照Spring Data JPA 定义的规则，查询方法以findBy开头，涉及条件查询时，条件的属性用条件关键字连接，要注意的是：条件属性首字母需大写。框架在进行方法名解析时，会先把方法名多余的前缀截取掉，然后对剩下部分进行解析。
//方法命名方式查询（根据客户名称查询客户）
public Customer findByCustName(String custName);

具体的关键字，使用方法和生产成SQL如下表所示

总代码

dao

public interface CustomerDao extends JpaRepository<Customer,Long> ,JpaSpecificationExecutor<Customer> {

    /**
     * 案例：根据客户名称查询客户
     *      使用jpql的形式查询
     *  jpql：from Customer where custName = ?
     *
     *  配置jpql语句，使用的@Query注解
     */
    @Query(value="from Customer where custName = ?")
    public Customer findJpql(String custName);


    /**
     * 案例：根据客户名称和客户id查询客户
     *      jpql： from Customer where custName = ? and custId = ?
     *
     *  对于多个占位符参数
     *      赋值的时候，默认的情况下，占位符的位置需要和方法参数中的位置保持一致
     *
     *  可以指定占位符参数的位置
     *      ? 索引的方式，指定此占位的取值来源
     */
    @Query(value = "from Customer where custName = ?2 and custId = ?1")
    public Customer findCustNameAndId(Long id,String name);

    /**
     * 使用jpql完成更新操作
     *      案例 ： 根据id更新，客户的名称
     *          更新4号客户的名称，将名称改为“aaa”
     *
     *  sql  ：update cst_customer set cust_name = ? where cust_id = ?
     *  jpql : update Customer set custName = ? where custId = ?
     *
     *  @Query : 代表的是进行查询
     *      * 声明此方法是用来进行更新操作
     *  @Modifying
     *      * 当前执行的是一个更新操作
     *
     */
    @Query(value = " update Customer set custName = ?2 where custId = ?1 ")
    @Modifying
    public void updateCustomer(long custId,String custName);


    /**
     * 使用sql的形式查询：
     *     查询全部的客户
     *  sql ： select * from cst_customer;
     *  Query : 配置sql查询
     *      value ： sql语句
     *      nativeQuery ： 查询方式
     *          true ： sql查询
     *          false：jpql查询
     *
     */
    //@Query(value = " select * from cst_customer" ,nativeQuery = true)
    @Query(value="select * from cst_customer where cust_name like ?1",nativeQuery = true)
    public List findSql(String name);


    /**
     * 方法名的约定：
     *      findBy : 查询
     *            对象中的属性名（首字母大写） ： 查询的条件
     *            CustName
     *            * 默认情况 ： 使用 等于的方式查询
     *                  特殊的查询方式
     *
     *  findByCustName   --   根据客户名称查询
     *
     *  再springdataJpa的运行阶段
     *          会根据方法名称进行解析  findBy    from  xxx(实体类)
     *                                      属性名称      where  custName =
     *
     *      1.findBy  + 属性名称 （根据属性名称进行完成匹配的查询=）
     *      2.findBy  + 属性名称 + “查询方式（Like | isnull）”
     *          findByCustNameLike
     *      3.多条件查询
     *          findBy + 属性名 + “查询方式”   + “多条件的连接符（and|or）”  + 属性名 + “查询方式”
     */
    public Customer findByCustName(String custName);


    public List findByCustNameLike(String custName);

    //使用客户名称模糊匹配和客户所属行业精准匹配的查询
    public Customer findByCustNameLikeAndCustIndustry(String custName,String custIndustry);
}
 
   
test
 
   
@RunWith(SpringJUnit4ClassRunner.class) //声明spring提供的单元测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml")//指定spring容器的配置信息
public class JpqlTest {
    @Autowired
    private CustomerDao customerDao;

    @Test
    public void  testFindJPQL() {
        Customer customer = customerDao.findJpql("aaa");
        System.out.println(customer);
    }


    @Test
    public void testFindCustNameAndId() {
       // Customer customer =  customerDao.findCustNameAndId("aaa",1l);
        Customer customer =  customerDao.findCustNameAndId(1l,"aaa");
        System.out.println(customer);
    }

    /**
     * 测试jpql的更新操作
     *  * springDataJpa中使用jpql完成 更新/删除操作
     *         * 需要手动添加事务的支持
     *         * 默认会执行结束之后，回滚事务
     *   @Rollback : 设置是否自动回滚
     *          false | true
     */
    @Test
    @Transactional //添加事务的支持
    @Rollback(value = false)
    public void testUpdateCustomer() {
        customerDao.updateCustomer(4l,"aaa");
    }

    //测试sql查询
    @Test
    public void testFindSql() {
        List list = customerDao.findSql("aaa%");
        for(Object [] obj : list) {
            System.out.println(Arrays.toString(obj));
        }
    }


    //测试方法命名规则的查询
    @Test
    public void testNaming() {
        Customer customer = customerDao.findByCustName("aaa");
        System.out.println(customer);
    }


    //测试方法命名规则的查询
    @Test
    public void testFindByCustNameLike() {
        List list = customerDao.findByCustNameLike("aaa%");
        for (Customer customer : list) {
            System.out.println(customer);
        }
    }


    //测试方法命名规则的查询
    @Test
    public void testFindByCustNameLikeAndCustIndustry() {
        Customer customer = customerDao.findByCustNameLikeAndCustIndustry("aaa1%", "it");
        System.out.println(customer);
    }
}
 
   
Specifications动态查询
 
   
     
    
  • 有时我们在查询某个实体的时候，给定的条件是不固定的，这时就需要动态构建相应的查询语句，在Spring Data JPA中可以通过JpaSpecificationExecutor接口查询。相比JPQL,其优势是类型安全,更加的面向对象。
    •  
   
 
   
import java.util.List;

import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;

/**
 *	JpaSpecificationExecutor中定义的方法
 **/
 public interface JpaSpecificationExecutor<T> {
   	//根据条件查询一个对象
 	T findOne(Specification spec);	
   	//根据条件查询集合
 	List findAll(Specification spec);
   	//根据条件分页查询
   	//Pageable:分页参数对象
 	Page findAll(Specification spec, Pageable pageable);
   	//排序查询查询
 	List findAll(Specification spec, Sort sort);
   	//统计查询
 	long count(Specification spec);
}
 
   
     
    
  • 对于JpaSpecificationExecutor，这个接口基本是围绕着Specification接口来定义的。我们可以简单的理解为，Specification构造的就是查询条件。
     
    •  
    
  • Specification接口中只定义了如下一个方法
     
    •  
   
 
   
//构造查询条件
/**
*	root	：Root接口，代表查询的根对象，可以通过root获取实体中的属性 （查询的任何属性都可以从根对象中获取）
*	query	：代表一个顶层查询对象，用来自定义查询(一般不用)
*	cb		：用来构建查询，此对象里有很多查询条件方法
**/
public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb);
 
   
使用Specifications完成条件查询
 
   
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class SpecTest {

    @Autowired
    private CustomerDao customerDao;

    /**
     * 根据条件，查询单个对象
     *
     */
    @Test
    public void testSpec() {
        //匿名内部类
        /**
         * 自定义查询条件
         *      1.实现Specification接口（提供泛型：查询的对象类型）
         *      2.实现toPredicate方法（构造查询条件）
         *      3.需要借助方法参数中的两个参数（
         *          root：获取需要查询的对象属性
         *          CriteriaBuilder：构造查询条件的，内部封装了很多的查询条件（模糊匹配，精准匹配）
         *       ）
         *  案例：根据客户名称查询，查询客户名为传智播客的客户
         *          查询条件
         *              1.查询方式
         *                  cb对象
         *              2.比较的属性名称
         *                  root对象
         *
         */
        Specification spec = new Specification() {
            @Override
            public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb) {
                //1.获取比较的属性
                Path custName = root.get("custId");
                //2.构造查询条件  ：    select * from cst_customer where cust_name = '传智播客'
                /**
                 * 第一个参数：需要比较的属性（path对象）
                 * 第二个参数：当前需要比较的取值
                 */
                Predicate predicate = cb.equal(custName, "aaa");//进行精准的匹配  （比较的属性，比较的属性的取值）
                return predicate;
            }
        };
        Customer customer = customerDao.findOne(spec);
        System.out.println(customer);
    }

    /**
     * 多条件查询
     *      案例：根据客户名（aaa）和客户所属行业查询（it）
     *
     */
    @Test
    public void testSpec1() {
        /**
         *  root:获取属性
         *      客户名
         *      所属行业
         *  cb：构造查询
         *      1.构造客户名的精准匹配查询
         *      2.构造所属行业的精准匹配查询
         *      3.将以上两个查询联系起来
         */
        Specification spec = new Specification() {
            @Override
            public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb) {
                Path custName = root.get("custName");//客户名
                Path custIndustry = root.get("custIndustry");//所属行业

                //构造查询
                //1.构造客户名的精准匹配查询
                Predicate p1 = cb.equal(custName, "aaa");//第一个参数，path（属性），第二个参数，属性的取值
                //2..构造所属行业的精准匹配查询
                Predicate p2 = cb.equal(custIndustry, "it");
                //3.将多个查询条件组合到一起：组合（满足条件一并且满足条件二：与关系，满足条件一或满足条件二即可：或关系）
                Predicate and = cb.and(p1, p2);//以与的形式拼接多个查询条件
                // cb.or();//以或的形式拼接多个查询条件
                return and;
            }
        };
        Customer customer = customerDao.findOne(spec);
        System.out.println(customer);
    }


    /**
     * 案例：完成根据客户名称的模糊匹配，返回客户列表
     *      客户名称以 ’aaa‘ 开头
     *
     * equal ：直接得到path对象（属性），然后进行比较即可
     * gt，lt,ge,le,like : 得到path对象，根据path指定比较的参数类型，再去进行比较
     *      指定参数类型：path.as(类型的字节码对象)
     */
    @Test
    public void testSpec3() {
        //构造查询条件
        Specification spec = new Specification() {
            @Override
            public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb) {
                //查询属性：客户名
                Path custName = root.get("custName");
                //查询方式：模糊匹配
                Predicate like = cb.like(custName.as(String.class), "aaa%");
                return like;
            }
        };
//        List list = customerDao.findAll(spec);
//        for (Customer customer : list) {
//            System.out.println(customer);
//        }
        //添加排序
        //创建排序对象,需要调用构造方法实例化sort对象
        //第一个参数：排序的顺序（倒序，正序）
        //   Sort.Direction.DESC:倒序
        //   Sort.Direction.ASC ： 升序
        //第二个参数：排序的属性名称
        Sort sort = new Sort(Sort.Direction.DESC,"custId");
        List list = customerDao.findAll(spec, sort);
        for (Customer customer : list) {
            System.out.println(customer);
        }
    }

    /**
     * 分页查询
     *      Specification: 查询条件
     *      Pageable：分页参数
     *          分页参数：查询的页码，每页查询的条数
     *          findAll(Specification,Pageable)：带有条件的分页
     *          findAll(Pageable)：没有条件的分页
     *  返回：Page（springDataJpa为我们封装好的pageBean对象，数据列表，总条数）
     */
    @Test
    public void testSpec4() {

        Specification spec = null;
        //PageRequest对象是Pageable接口的实现类
        /**
         * 创建PageRequest的过程中，需要调用他的构造方法传入两个参数
         *      第一个参数：当前查询的页数（从0开始）
         *      第二个参数：每页查询的数量
         */
        Pageable pageable = new PageRequest(0,2);
        //分页查询
        Page page = customerDao.findAll(null, pageable);
        System.out.println(page.getContent()); //得到数据集合列表
        System.out.println(page.getTotalElements());//得到总条数
        System.out.println(page.getTotalPages());//得到总页数
    }
}
 
   
基于Specifications的分页查询
 
   
@Test
public void testPage() {
	//构造查询条件
	Specification spec = new Specification() {
		public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb) {
			return cb.like(root.get("custName").as(String.class), "a%");
		}
	};
	
	/**
	 * 构造分页参数
	 * 		Pageable : 接口
	 * 			PageRequest实现了Pageable接口，调用构造方法的形式构造
	 * 				第一个参数：页码（从0开始）
	 * 				第二个参数：每页查询条数
	 */
	Pageable pageable = new PageRequest(0, 5);
	
	/**
	 * 分页查询，封装为Spring Data Jpa 内部的page bean
	 * 		此重载的findAll方法为分页方法需要两个参数
	 * 			第一个参数：查询条件Specification
	 * 			第二个参数：分页参数
	 */
	Page page = customerDao.findAll(spec,pageable);
	
}
 
   
     
    
  • 对于Spring Data JPA中的分页查询，是其内部自动实现的封装过程，返回的是一个Spring Data JPA提供的pageBean对象
    •  
   
 
   
 //获取总页数
int getTotalPages();
 //获取总记录数	
long getTotalElements();
//获取列表数据
List getContent();
 
   
方法对应关系
 
   
 
     
     
 
       
       
     
 
     
     
     
 
      方法名称 
      Sql对应关系 
     
 
     
 
      equle 
      filed = value 
     
 
     
 
      gt（greaterThan ） 
      filed > value 
     
 
     
 
      lt（lessThan ） 
      filed < value 
     
 
     
 
      ge（greaterThanOrEqualTo ） 
      filed >= value 
     
 
     
 
      le（ lessThanOrEqualTo） 
      filed <= value 
     
 
     
 
      notEqule 
      filed != value 
     
 
     
 
      like 
      filed like value 
     
 
     
 
      notLike 
      filed not like value 
     
 
     
   
 
   
JPA中的一对多
 
   
在JPA框架中表关系的分析步骤
 
   
     
    
  • 第一步：首先确定两张表之间的关系。 
     
       
      
    • 如果关系确定错了，后面做的所有操作就都不可能正确。
      •  
     
     
    •  
    
  • 第二步：在数据库中实现两张表的关系（外键｜中间表）
    •  
    
  • 第三步：在实体类中描述出两个实体的关系（包含关系）
    •  
    
  • 第四步：配置出实体类和数据库表的关系映射
    •  
   
 
   
实体类关系建立以及映射配置
 
   
     
    
  • 例如：在实体类中，由于客户是少的一方，它应该包含多个联系人，所以实体类要体现出客户中有多个联系人的信息，代码如下：
    •  
   
 
   
domain和dao
 
   
### customer.java

@Entity
@Table(name="cst_customer")
public class Customer {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="cust_id")
    private Long custId;
    @Column(name="cust_address")
    private String custAddress;
    ...

    //配置客户和联系人之间的关系（一对多关系）
    /**
     * 使用注解的形式配置多表关系
     *      1.声明关系
     *          @OneToMany : 配置一对多关系
     *              targetEntity ：对方对象的字节码对象
     *      2.配置外键（中间表）
     *              @JoinColumn : 配置外键
     *                  name：外键字段名称
     *                  referencedColumnName：参照的主表的主键字段名称
     *
     *  * 在客户实体类上（一的一方）添加了外键了配置，所以对于客户而言，也具备了维护外键的作用
     *
     */

    @OneToMany(targetEntity = LinkMan.class)
    @JoinColumn(name = "lkm_cust_id",referencedColumnName = "cust_id")

    @OneToMany(mappedBy = "customer",cascade = CascadeType.ALL)
    private Set linkMans = new HashSet<>();



### linkman.java

@Entity
@Table(name = "cst_linkman")
public class LinkMan {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "lkm_id")
    private Long lkmId; //联系人编号(主键)
    @Column(name = "lkm_name")
    private String lkmName;//联系人姓名
    ...

    /**
     * 配置联系人到客户的多对一关系
     *     使用注解的形式配置多对一关系
     *      1.配置表关系
     *          @ManyToOne : 配置多对一关系
     *              targetEntity：对方的实体类字节码
     *      2.配置外键（中间表）
     *
     * * 配置外键的过程，配置到了多的一方，就会在多的一方维护外键
     *
     */
    @ManyToOne(targetEntity = Customer.class,fetch = FetchType.LAZY)
    @JoinColumn(name = "lkm_cust_id",referencedColumnName = "cust_id")
    private Customer customer;
 
   
/**
 * 联系人的dao接口
 */
public interface LinkManDao extends JpaRepository<LinkMan,Long>, JpaSpecificationExecutor<LinkMan> {
}

...
 
   
application.xml添加代码
 
   

"jpaProperties" >
    
        update
    

 
   
映射的注解说明
 
   
@OneToMany:
 
   
     
    
  • 作用：建立一对多的关系映射
    •  
    
  • 属性： 
     
       
      
    • targetEntityClass：指定多的多方的类的字节码
      •  
      
    • mappedBy：指定从表实体类中引用主表对象的名称。
      •  
      
    • cascade：指定要使用的级联操作
      •  
      
    • fetch：指定是否采用延迟加载
      •  
      
    • orphanRemoval：是否使用孤儿删除
      •  
     
     
    •  
   
 
   
@ManyToOne
 
   
     
    
  • 作用：建立多对一的关系
    •  
    
  • 属性： 
     
       
      
    • targetEntityClass：指定一的一方实体类字节码
      •  
      
    • cascade：指定要使用的级联操作
      •  
      
    • fetch：指定是否采用延迟加载
      •  
      
    • optional：关联是否可选。如果设置为false，则必须始终存在非空关系。
      •  
     
     
    •  
   
 
   
@JoinColumn
 
   
     
    
  • 作用：用于定义主键字段和外键字段的对应关系。
    •  
    
  • 属性： 
     
       
      
    • name：指定外键字段的名称
      •  
      
    • referencedColumnName：指定引用主表的主键字段名称
      •  
      
    • unique：是否唯一。默认值不唯一
      •  
      
    • nullable：是否允许为空。默认值允许。
      •  
      
    • insertable：是否允许插入。默认值允许。
      •  
      
    • updatable：是否允许更新。默认值允许。
      •  
      
    • columnDefinition：列的定义信息。
      •  
     
     
    •  
   
 
   
删除
 
   
     
    
  • 从表数据：可以随时任意删除。
     
    •  
    
  • 主表数据：
     
    •  
    
  • 有从表数据
     
     
       
      
    1. 在默认情况下，它会把外键字段置为null，然后删除主表数据。如果在数据库的表 结构上，外键字段有非空约束，默认情况就会报错了。
      2.  
      
    2. 如果配置了放弃维护关联关系的权利，则不能删除（与外键字段是否允许为null,没有关系）因为在删除时，它根本不会去更新从表的外键字段了。
      3.  
      
    3. 如果还想删除，使用级联删除引用
      4.  
     
     
    •  
    
  • 没有从表数据引用：随便删
     
    •  
   
 
   
test
 
   
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class OneToManyTest {

    @Autowired
    private CustomerDao customerDao;

    @Autowired
    private LinkManDao linkManDao;

    /**
     * 保存一个客户，保存一个联系人
     *  效果：客户和联系人作为独立的数据保存到数据库中
     *      联系人的外键为空
     *  原因？
     *      实体类中没有配置关系
     */
    @Test
    @Transactional //配置事务
    @Rollback(false) //不自动回滚
    public void testAdd() {
        //创建一个客户，创建一个联系人
        Customer customer = new Customer();
        customer.setCustName("百度");

        LinkMan linkMan = new LinkMan();
        linkMan.setLkmName("小李");

        /**
         * 配置了客户到联系人的关系
         *      从客户的角度上：发送两条insert语句，发送一条更新语句更新数据库（更新外键）
         * 由于我们配置了客户到联系人的关系：客户可以对外键进行维护
         */
        customer.getLinkMans().add(linkMan);


        customerDao.save(customer);
        linkManDao.save(linkMan);
    }


    @Test
    @Transactional //配置事务
    @Rollback(false) //不自动回滚
    public void testAdd1() {
        //创建一个客户，创建一个联系人
        Customer customer = new Customer();
        customer.setCustName("百度");

        LinkMan linkMan = new LinkMan();
        linkMan.setLkmName("小李");

        /**
         * 配置联系人到客户的关系（多对一）
         *    只发送了两条insert语句
         * 由于配置了联系人到客户的映射关系（多对一）
         *
         *
         */
        linkMan.setCustomer(customer);

        customerDao.save(customer);
        linkManDao.save(linkMan);
    }

    /**
     * 会有一条多余的update语句
     *      * 由于一的一方可以维护外键：会发送update语句
     *      * 解决此问题：只需要在一的一方放弃维护权即可
     *
     */
    @Test
    @Transactional //配置事务
    @Rollback(false) //不自动回滚
    public void testAdd2() {
        //创建一个客户，创建一个联系人
        Customer customer = new Customer();
        customer.setCustName("百度");

        LinkMan linkMan = new LinkMan();
        linkMan.setLkmName("小李");


        linkMan.setCustomer(customer);//由于配置了多的一方到一的一方的关联关系（当保存的时候，就已经对外键赋值）
        customer.getLinkMans().add(linkMan);//由于配置了一的一方到多的一方的关联关系（发送一条update语句）

        customerDao.save(customer);
        linkManDao.save(linkMan);
    }
 
   
级联操作
 
   
     
    
  • 级联操作：指操作一个对象同时操作它的关联对象
     
    •  
    
  • 使用方法：只需要在操作主体的注解上配置cascade
     
    •  
   
 
   
/**
 * cascade:配置级联操作
 * 		CascadeType.MERGE	级联更新
 * 		CascadeType.PERSIST	级联保存：
 * 		CascadeType.REFRESH 级联刷新：
 * 		CascadeType.REMOVE	级联删除：
 * 		CascadeType.ALL		包含所有
 */
@OneToMany(mappedBy="customer",cascade=CascadeType.ALL)
private Set linkMans = new HashSet<>();
 
   
JPA中的多对多
 
   
映射的注解说明
 
   
@ManyToMany
 
   
     
    
  • 作用：用于映射多对多关系
    •  
    
  • 属性： 
     
       
      
    • cascade：配置级联操作。
      •  
      
    • fetch：配置是否采用延迟加载。
      •  
      
    • targetEntity：配置目标的实体类。映射多对多的时候不用写。
      •  
     
     
    •  
   
 
   
@JoinTable
 
   
     
    
  • 作用：针对中间表的配置
    •  
    
  • 属性： 
     
       
      
    • nam：配置中间表的名称
      •  
      
    • joinColumns：中间表的外键字段关联当前实体类所对应表的主键
      •  
      
    • inverseJoinColumn：中间表的外键字段关联对方表的主键字段
      •  
     
     
    •  
   
 
   
@JoinColumn
 
   
     
    
  • 作用：用于定义主键字段和外键字段的对应关系。
    •  
    
  • 属性： 
     
       
      
    • name：指定外键字段的名称
      •  
      
    • referencedColumnName：指定引用主表的主键字段名称
      •  
      
    • unique：是否唯一。默认值不唯一
      •  
      
    • nullable：是否允许为空。默认值允许。
      •  
      
    • insertable：是否允许插入。默认值允许。
      •  
      
    • updatable：是否允许更新。默认值允许。
      •  
      
    • columnDefinition：列的定义信息。
      •  
     
     
    •  
   
 
   
示例代码
 
   
domain
 
   
### user.java
@Entity
@Table(name = "sys_user")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="user_id")
    private Long userId;
    @Column(name="user_name")
    private String userName;
    @Column(name="age")
    private Integer age;

    /**
     * 配置用户到角色的多对多关系
     *      配置多对多的映射关系
     *          1.声明表关系的配置
     *              @ManyToMany(targetEntity = Role.class)  //多对多
     *                  targetEntity：代表对方的实体类字节码
     *          2.配置中间表（包含两个外键）
     *                @JoinTable
     *                  name : 中间表的名称
     *                  joinColumns：配置当前对象在中间表的外键
     *                      @JoinColumn的数组
     *                          name：外键名
     *                          referencedColumnName：参照的主表的主键名
     *                  inverseJoinColumns：配置对方对象在中间表的外键
     */
    @ManyToMany(targetEntity = Role.class,cascade = CascadeType.ALL)
    @JoinTable(name = "sys_user_role",
            //joinColumns,当前对象在中间表中的外键
            joinColumns = {@JoinColumn(name = "sys_user_id",referencedColumnName = "user_id")},
            //inverseJoinColumns，对方对象在中间表的外键
            inverseJoinColumns = {@JoinColumn(name = "sys_role_id",referencedColumnName = "role_id")}
    )
    private Set roles = new HashSet<>();
    
    
### role.java

@Entity
@Table(name = "sys_role")
public class Role {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "role_id")
    private Long roleId;
    @Column(name = "role_name")
    private String roleName;

    @JoinTable(name = "sys_user_role",
            //joinColumns,当前对象在中间表中的外键
            joinColumns = {@JoinColumn(name = "sys_role_id",referencedColumnName = "role_id")},
            //inverseJoinColumns，对方对象在中间表的外键
            inverseJoinColumns = {@JoinColumn(name = "sys_user_id",referencedColumnName = "user_id")}  
     private Set users = new HashSet<>();
 
   
test
 
   
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class ManyToManyTest {

    @Autowired
    private UserDao userDao;
    @Autowired
    private RoleDao roleDao;

    /**
     * 保存一个用户，保存一个角色
     *
     *  多对多放弃维护权：被动的一方放弃
     */
    @Test
    @Transactional
    @Rollback(false)
    public void  testAdd() {
        User user = new User();
        user.setUserName("小李");

        Role role = new Role();
        role.setRoleName("java程序员");

        //配置用户到角色关系，可以对中间表中的数据进行维护     1-1
        user.getRoles().add(role);

        //配置角色到用户的关系，可以对中间表的数据进行维护     1-1
        role.getUsers().add(user);

        userDao.save(user);
        roleDao.save(role);
    }


    //测试级联添加（保存一个用户的同时保存用户的关联角色）
    @Test
    @Transactional
    @Rollback(false)
    public void  testCasCadeAdd() {
        User user = new User();
        user.setUserName("小李");

        Role role = new Role();
        role.setRoleName("java程序员");

        //配置用户到角色关系，可以对中间表中的数据进行维护     1-1
        user.getRoles().add(role);

        //配置角色到用户的关系，可以对中间表的数据进行维护     1-1
        role.getUsers().add(user);

        userDao.save(user);
    }

    /**
     * 案例：删除id为1的用户，同时删除他的关联对象
     */
    @Test
    @Transactional
    @Rollback(false)
    public void  testCasCadeRemove() {
        //查询1号用户
        User user = userDao.findOne(1l);
        //删除1号用户
        userDao.delete(user);

    }
}
 
   
     
    
  • 在多对多（保存）中，如果双向都设置关系，意味着双方都维护中间表，都会往中间表插入数据，中间表的2个字段又作为联合主键，所以报错，主键重复，解决保存失败的问题：只需要在任意一方放弃对中间表的维护权即可，推荐在被动的一方放弃
    •  
   
 
   
//放弃对中间表的维护权，解决保存中主键冲突的问题
@ManyToMany(mappedBy="roles")
private Set users = new HashSet(0);
 
   
     
    
  • 删除
    •  
   
 
   
@Autowired
private UserDao userDao;
/**
 * 删除操作
 * 	在多对多的删除时，双向级联删除根本不能配置
 * 禁用
 *	如果配了的话，如果数据之间有相互引用关系，可能会清空所有数据
 */
@Test
@Transactional
@Rollback(false)//设置为不回滚
public void testDelete() {
	userDao.delete(1l);
}
 
   
Spring Data JPA中的多表查询
 
   
对象导航查询
 
   
     
    
  • 对象图导航检索方式是根据已经加载的对象，导航到他的关联对象。它利用类与类之间的关系来检索对象。例如：我们通过ID查询方式查出一个客户，可以调用Customer类中的getLinkMans()方法来获取该客户的所有联系人。对象导航查询的使用要求是：两个对象之间必须存在关联关系
     
    •  
    
  • 查询一个客户，获取该客户下的所有联系人
     
    •  
   
 
   
@Autowired
private CustomerDao customerDao;
	
@Test
//由于是在java代码中测试，为了解决no session问题，将操作配置到同一个事务中
@Transactional 
public void testFind() {
	Customer customer = customerDao.findOne(5l);
	Set linkMans = customer.getLinkMans();//对象导航查询
	for(LinkMan linkMan : linkMans) {
		System.out.println(linkMan);
	}
}
 
   
     
    
  • 查询一个联系人，获取该联系人的所有客户
    •  
   
 
   
@Autowired
private LinkManDao linkManDao;
	
	
@Test
public void testFind() {
	LinkMan linkMan = linkManDao.findOne(4l);
	Customer customer = linkMan.getCustomer(); //对象导航查询
	System.out.println(customer);
}
 
   
延迟加载
 
   
     
    
  • 延迟加载的思想。通过配置的方式来设定当我们在需要使用时，发起真正的查询。
    •  
    
  • 对象导航查询默认使用的是延迟加载的形式查询的
    •  
   
 
   
/**
 * 在客户对象的@OneToMany注解中添加fetch属性
 * 		FetchType.EAGER	：立即加载
 * 		FetchType.LAZY	：延迟加载
 */
@OneToMany(mappedBy="customer",fetch=FetchType.EAGER)
private Set linkMans = new HashSet<>(0);
 
   
使用Specification查询
 
   
/**
 * Specification的多表查询
 */
@Test
public void testFind() {
	Specification spec = new Specification() {
		public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb) {
			//Join代表链接查询，通过root对象获取
			//创建的过程中，第一个参数为关联对象的属性名称，第二个参数为连接查询的方式（left，inner，right）
			//JoinType.LEFT : 左外连接,JoinType.INNER：内连接,JoinType.RIGHT：右外连接
			Join join = root.join("customer",JoinType.INNER);
			return cb.like(join.get("custName").as(String.class),"传智播客1");
		}
	};
	List list = linkManDao.findAll(spec);
	for (LinkMan linkMan : list) {
		System.out.println(linkMan);
	}
}
 
   
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(JAVA框架08 -- Spring Data JPA)

        

            

                
    
                    
  • 2021-08-26
                        影幽

                        
    在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
    
                    
    • 
                    
  • 2022-07-08
                        保利学府里李楚怡1307022

                        
    ——保利碧桂园学府里——童梦奇趣【科学实验室】「7.9-7.10」✏玩出大智慧约99-144㎡二期全新升级力作
    
                    
    • 
                    
  • WPF中的ComboBox控件几种数据绑定的方式
                        互联网打工人no1
wpfc#
                        
    一、用字典给ItemsSource赋值（此绑定用的地方很多，建议熟练掌握）在XMAL中：在CS文件中privatevoidBindData(){DictionarydicItem=newDictionary();dicItem.add(1,"北京");dicItem.add(2,"上海");dicItem.add(3,"广州");cmb_list.ItemsSource=dicItem;cmb_l
    
                    
    • 
                    
  • 将cmd中命令输出保存为txt文本文件
                        落难Coder
Windowscmdwindow
                        
    最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
    
                    
    • 
                    
  • 2019-08-08
                        65454

                        
    东莞家庭聚会出行旅游去哪里玩住？想起来有很久没有和家里人聚会啦，这次组织家人来到威廉古堡别墅轰趴，一大家子27个人，在别墅订了一天办，玩的非常的开心，小孩子玩游戏机，也很放心不会丢，我们就在唱歌、打麻将、打桌球一系列的活动，还准备小次等小孩生日在别墅举办，还可以给孩子做一个生日的策划
    
                    
    • 
                    
  • 2019-08-16
                        希望在东方

                        
    《春游荣华山》春游荣华山，乍暖还寒。青苔路，石阶险。山路弯上弯！为寻古寺往幽探。细雨已润江南岸，初春芳草现。老树新芽冒枝端，人间又过到新年。今游荣华山，树茂参天，古寺悠闲。细雨飘落发端！三眼井旁，投币许心愿，并祷一世安然。更喜大女明事端，应心安，放开颜。修竹静默，雨中吐心愿。待得春风浩吹时，春笋节节攀。图片发自App图片发自App图片发自App
    
                    
    • 
                    
  • 2021-08-09
                        杜永鹏

                        
    京❤️达总店：杜永鹏2021年8月9日落地真经严格就是爱，放纵既是害目标确认目标:产值目标165000台次目标100油卡目标10体验：在工作中遇到问题不要盲目的去干，要多方面考虑问题，找到问题的关键克服困难并解决问题！
    
                    
    • 
                    
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞
                        文章永久免费只为良心
oracle数据库
                        
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
    
                    
    • 
                    
  • Linux MariaDB使用OpenSSL安装SSL证书
                        Meta39
MySQLOracleMariaDBLinuxWindowsssllinuxmariadb
                        
    进入到证书存放目录，批量删除.pem证书警告：确保已经进入到证书存放目录find.-typef-iname\*.pem-delete查看是否安装OpenSSLopensslversion没有则安装yuminstallopensslopenssl-devel开启SSL编辑/etc/my.cnf文件（没有的话就创建，但是要注意，在/etc/my.cnf.d/server.cnf配置了datadir的，
    
                    
    • 
                    
  • 2022-08-28
                        蔚蓝一片晴

                        
    初三暑假培训收获点滴从8月25至8月27日三天两晚的培训结束了，回到家中，该静下心来整理一下触动心灵的收获，成为成长的积淀。1.在优秀团队中快速成长与提升，做一名反思成长型教师一名专业型教师的教学指导包括了教学原理知识、案例知识、策略知识。面对教学中的遇到的有趣的情形、问题会去研究其理，寻找更好的教法学法对策。从新手到成熟型教师，再走向专业型教师，需要的是觉醒与反思，多进行案例研究，从案例中观察、
    
                    
    • 
                    
  • 网络编程基础
                        记得开心一点啊
网络
                        
    目录♫什么是网络编程♫Socket套接字♪什么是Socket套接字♪数据报套接字♪流套接字♫数据报套接字通信模型♪数据报套接字通讯模型♪DatagramSocket♪DatagramPacket♪实现UDP的服务端代码♪实现UDP的客户端代码♫流套接字通信模型♪流套接字通讯模型♪ServerSocket♪Socket♪实现TCP的服务端代码♪实现TCP的客户端代码♫什么是网络编程网络编程，指网络上
    
                    
    • 
                    
  • K近邻算法_分类鸢尾花数据集
                        _feivirus_
算法机器学习和数学分类机器学习K近邻
                        
    importnumpyasnpimportpandasaspdfromsklearn.datasetsimportload_irisfromsklearn.model_selectionimporttrain_test_splitfromsklearn.metricsimportaccuracy_score1.数据预处理iris=load_iris()df=pd.DataFrame(data=ir
    
                    
    • 
                    
  • 2023-08-08
                        2023梦启支教团张牧泽

                        
    学汉字历史，行传统书法——中国矿业大学梦启支教团梦启三班开展书法文化课7月20日上午8时，中国矿业大学梦启支教团在贵州省金沙县西洛街道彩虹小学开展了“书法文化”课程。该课程意在向孩子们传授汉字演变的相关知识，围绕书法发展历史讲解不同时期的字形字体特点。此课程由梦启支教团成员王耀民讲授，梦启三班全体成员参加。中国文字的发展有数千年的历史，从早期雏形的象形文字到殷商时期的甲骨文、金文，再到西周、秦朝的
    
                    
    • 
                    
  • (158)时序收敛---＞(08)时序收敛八
                        FPGA系统设计指南针
FPGA系统设计(内训)fpga开发时序收敛
                        
    1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛八（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）F
    
                    
    • 
                    
  • spring如何整合druid连接池？
                        惜.己
springspringjunit数据库javaidea后端xml
                        
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
    
                    
    • 
                    
  • 4.C_数据结构_队列
                        荣世蓥
数据结构数据结构
                        
    概述什么是队列：队列是限定在两端进行插入操作和删除操作的线性表。具有先入先出(FIFO)的特点相关名词：队尾：写入数据的一段队头：读取数据的一段空队：队列中没有数据，队头指针=队尾指针满队：队列中存满了数据，队尾指针+1=队头指针循环队列1、基本内容循环队列是以数组形式构成的队列数据结构。循环队列的结构体如下：typedefintdata_t;//队列数据类型#defineN64//队列容量typ
    
                    
    • 
                    
  • vue项目element-ui的table表格单元格合并
                        酋长哈哈
vue.jselementuijavascript前端
                        
    一、合并效果二全部代码exportdefault{name:'CellMerge',data(){return{tableData:[{id:'1',name:'王小虎',amount1:'165',amount2:'3.2',amount3:10},{id:'1',name:'王小虎',amount1:'162',amount2:'4.43',amount3:12},{id:'1',name:'
    
                    
    • 
                    
  • python tif转png
                        Python与遥感
python开发语言
                        
    importosfromosgeoimportgdalimportnumpyasnpfromPILimportImage#提取432三波段fromspectralimport*#输入文件夹路径defget_img(dataset_img):width=dataset_img.RasterXSize#获取行列数height=dataset_img.RasterYSizebands=dataset_i
    
                    
    • 
                    
  • MongoDB知识概括
                        GeorgeLin98
持久层mongodb
                        
    MongoDB知识概括MongoDB相关概念单机部署基本常用命令索引-IndexSpirngDataMongoDB集成副本集分片集群安全认证MongoDB相关概念业务应用场景：传统的关系型数据库（如MySQL），在数据操作的“三高”需求以及应对Web2.0的网站需求面前，显得力不从心。解释：“三高”需求：①Highperformance-对数据库高并发读写的需求。②HugeStorage-对海量数
    
                    
    • 
                    
  • 2023-08-20
                        圆梦菌

                        
    魔力宝贝最详细新手教程，新手该如何完美开局，建议收藏转发2023-08-2010:34《魔力宝贝》手游体力是什么?魔力宝贝体力恢复机制是每10分钟回复1点；体力作用：挑战关卡需消耗体力体力获取方式1、好友每天可以赠送15次，也就是15点体力2、系统每天中午12点以及下午6点赠送25体3、在商城使用神石购买《魔力宝贝》手游战斗力如何提升?1、宠物强化宠物通过融合进阶后可以大幅度提升战力，最高级的宠物
    
                    
    • 
                    
  • Vue中table合并单元格用法
                        weixin_30613343
javascriptViewUI
                        
    地名结果人名性别{{item.name}}已完成未完成{{item.groups[0].name}}{{item.groups[0].sex}}{{item.groups[son].name}}{{item.groups[son].sex}}exportdefault{data(){return{list:[{name:'地名1',result:'1',groups:[{name:'张三',sex
    
                    
    • 
                    
  • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    
                    
    • 
                    
  • uniapp map组件自定义markers标记点
                        以对_
uni-app学习记录uni-appjavascript前端
                        
    需求是根据后端返回数据在地图上显示标记点，并且根据数据状态控制标记点颜色，标记点背景通过两张图片实现控制{{item.options.labelName}}exportdefault{data(){return{storeIndex:0,locaInfo:{longitude:120.445172,latitude:36.111387},markers:[//标点列表{id:1,//标记点idin
    
                    
    • 
                    
  • Spring MVC 全面指南：从入门到精通的详细解析
                        一杯梅子酱
技术栈学习springmvcjava
                        
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    
                    
    • 
                    
  • 2023-08-11
                        Tom梁

                        
    当下，文玩之风可谓风靡，喜欢星月菩提的玩友越来多。有许多玩友发私信来问小编“盘玩星月菩提有没有攻略？”。所以今天给大家分享实用的星月菩提盘玩攻略，希望对大家有所帮助。一、挑选方法大家都知道挑选星月菩提的唯一标准就是密度。密度越低，上色越快；密度越高，上色就越慢。但是小编觉得高密籽更适合盘玩，虽然上色慢，但耐盘，生命周期比低密度的要长很多。那么怎么去判断它的密度呢？其实很简单，看星眼的大小、疏密、颜
    
                    
    • 
                    
  • Spring Boot中实现跨域请求
                        BABA8891
springboot后端java
                        
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • vue + Element UI table动态合并单元格
                        我家媳妇儿萌哒哒
elementUIvue.js前端javascript
                        
    一、功能需求1、根据名称相同的合并工作阶段和主要任务合并这两列，但主要任务内容一样，但要考虑主要任务一样，但工作阶段不一样的情况。（枞向合并）2、落实情况里的定量内容和定性内容值一样则合并。（横向合并）二、功能实现exportdefault{data(){return{tableData:[{name:'a',address:'1',age:'1',six:'2'},{name:'a',addre
    
                    
    • 
                    
  • 00. 这里整理了最全的爬虫框架（Java + Python）
                        有一只柴犬
爬虫系列爬虫javapython
                        
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
    
                    
    • 
                                
  • LeetCode[Math] - #66 Plus One
                                    Cwind
javaLeetCode题解AlgorithmMath
                                    
    原题链接：#66 Plus One 
  
要求： 
给定一个用数字数组表示的非负整数，如num1 = {1, 2, 3, 9}, num2 = {9, 9}等，给这个数加上1。 
注意： 
1. 数字的较高位存在数组的头上，即num1表示数字1239 
2. 每一位（数组中的每个元素）的取值范围为0~9 
  
难度：简单 
  
分析： 
题目比较简单，只须从数组
    
                                
    • 
                                
  • JQuery中$.ajax()方法参数详解
                                    AILIKES
JavaScriptjsonpjqueryAjaxjson
                                    
    url: 要求为String类型的参数，（默认为当前页地址）发送请求的地址。 
type: 要求为String类型的参数，请求方式（post或get）默认为get。注意其他http请求方法，例如put和    delete也可以使用，但仅部分浏览器支持。 
timeout: 要求为Number类型的参数，设置请求超时时间（毫秒）。此设置将覆盖$.ajaxSetup()方法的全局
    
                                
    • 
                                
  • JConsole & JVisualVM远程监视Webphere服务器JVM
                                    Kai_Ge
JVisualVMJConsoleWebphere
                                    
        JConsole是JDK里自带的一个工具，可以监测Java程序运行时所有对象的申请、释放等动作，将内存管理的所有信息进行统计、分析、可视化。我们可以根据这些信息判断程序是否有内存泄漏问题。 
　　使用JConsole工具来分析WAS的JVM问题，需要进行相关的配置。 
　　首先我们看WAS服务器端的配置. 
　　1、登录was控制台https://10.4.119.18
    
                                
    • 
                                
  • 自定义annotation
                                    120153216
annotation
                                    
    Java annotation 自定义注释@interface的用法  一、什么是注释  
 
    说起注释，得先提一提什么是元数据(metadata)。所谓元数据就是数据的数据。也就是说，元数据是描述数据的。就象数据表中的字段一样，每个字段描述了这个字段下的数据的含义。而J2SE5.0中提供的注释就是java源代码的元数据，也就是说注释是描述java源
    
                                
    • 
                                
  • CentOS 5/6.X 使用 EPEL YUM源
                                    2002wmj
centos
                                    
    CentOS 6.X 安装使用EPEL YUM源1. 查看操作系统版本[root@node1 ~]# uname -a Linux node1.test.com 2.6.32-358.el6.x86_64 #1 SMP Fri Feb 22 00:31:26 UTC 2013 x86_64 x86_64 x86_64 GNU/Linux [root@node1 ~]#
    
                                
    • 
                                
  • 在SQLSERVER中查找缺失和无用的索引SQL
                                    357029540
SQL Server
                                    
    --缺失的索引 
SELECT  avg_total_user_cost * avg_user_impact * ( user_scans + user_seeks ) AS PossibleImprovement ,  
        last_user_seek ,  
  
    
                                
    • 
                                
  • Spring3 MVC 笔记（二） —json+rest优化
                                    7454103
Spring3 MVC
                                    
    接上次的 spring mvc 注解的一些详细信息！ 
                         其实也是一些个人的学习笔记  呵呵！ 
 

    
                                
    • 
                                
  • 替换“\”的时候报错Unexpected internal error near index 1 \ ^
                                    adminjun
java“\替换”
                                    
    发现还是有些东西没有刻子脑子里,,过段时间就没什么概念了,所以贴出来...以免再忘... 
  
在拆分字符串时遇到通过 \ 来拆分，可是用所以想通过转义 \\ 来拆分的时候会报异常 
   
 
 public class Main {   
    
     /*
    
                                
    • 
                                
  • POJ 1035 Spell checker(哈希表)
                                    aijuans
暴力求解--哈希表
                                    
    /*
题意：输入字典，然后输入单词，判断字典中是否出现过该单词，或者是否进行删除、添加、替换操作，如果是，则输出对应的字典中的单词
要求按照输入时候的排名输出

题解：建立两个哈希表。一个存储字典和输入字典中单词的排名，一个进行最后输出的判重
*/

#include <iostream>
//#define 
using namespace std;
const int HASH =
    
                                
    • 
                                
  • 通过原型实现javascript Array的去重、最大值和最小值
                                    ayaoxinchao
JavaScriptarrayprototype
                                    
    用原型函数（prototype）可以定义一些很方便的自定义函数，实现各种自定义功能。本次主要是实现了Array的去重、获取最大值和最小值。 
实现代码如下： 
  
<script type="text/javascript">
	Array.prototype.unique = function() {
		var a = {};
		var le
    
                                
    • 
                                
  • UIWebView实现https双向认证请求
                                    bewithme
UIWebViewhttpsObjective-C
                                    
      
        什么是HTTPS双向认证我已在先前的博文 ASIHTTPRequest实现https双向认证请求 
中有讲述，不理解的读者可以先复习一下。本文是用UIWebView来实现对需要客户端证书验证的服务请求，网上有些文章中有涉及到此内容，但都只言片语，没有讲完全，更没有完整的代码，让人困扰不已。但是此知
    
                                
    • 
                                
  • NoSQL数据库之Redis数据库管理(Redis高级应用之事务处理、持久化操作、pub_sub、虚拟内存)
                                    bijian1013
redis数据库NoSQL
                                    
    3.事务处理 
        Redis对事务的支持目前不比较简单。Redis只能保证一个client发起的事务中的命令可以连续的执行，而中间不会插入其他client的命令。当一个client在一个连接中发出multi命令时，这个连接会进入一个事务上下文，该连接后续的命令不会立即执行，而是先放到一个队列中，当执行exec命令时，redis会顺序的执行队列中
    
                                
    • 
                                
  • 各数据库分页sql备忘
                                    bingyingao
oraclesql分页
                                    
    ORACLE 
 
下面这个效率很低 
SELECT * FROM ( SELECT A.*, ROWNUM RN FROM (SELECT * FROM IPAY_RCD_FS_RETURN order by id desc) A ) WHERE RN <20; 
 
下面这个效率很高 
SELECT A.*, ROWNUM RN FROM (SELECT * FROM IPAY_RCD_
    
                                
    • 
                                
  • 【Scala七】Scala核心一：函数
                                    bit1129
scala
                                    
    1. 如果函数体只有一行代码，则可以不用写{},比如 
def print(x: Int) = println(x) 
一行上的多条语句用分号隔开，则只有第一句属于方法体，例如 
  
def printWithValue(x: Int) : String= println(x); "ABC" 
  
上面的代码报错，因为，printWithValue的方法
    
                                
    • 
                                
  • 了解GHC的factorial编译过程
                                    bookjovi
haskell
                                    
    GHC相对其他主流语言的编译器或解释器还是比较复杂的，一部分原因是haskell本身的设计就不易于实现compiler，如lazy特性，static typed，类型推导等。 
关于GHC的内部实现有篇文章说的挺好，这里，文中在RTS一节中详细说了haskell的concurrent实现，里面提到了green thread，如果熟悉Go语言的话就会发现，ghc的concurrent实现和Go有点类
    
                                
    • 
                                
  • Java-Collections Framework学习与总结-LinkedHashMap
                                    BrokenDreams
LinkedHashMap
                                    
            前面总结了java.util.HashMap，了解了其内部由散列表实现，每个桶内是一个单向链表。那有没有双向链表的实现呢？双向链表的实现会具备什么特性呢？来看一下HashMap的一个子类——java.util.LinkedHashMap。 
      
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-抽象工厂模式-Abstract Factory
                                    bylijinnan
abstract
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 


package design.pattern;

/*
 * Abstract Factory Pattern
 * 抽象工厂模式的目的是：
 * 通过在抽象工厂里面定义一组产品接口，方便地切换“产品簇”
 * 这些接口是相关或者相依赖的
    
                                
    • 
                                
  • 压暗面部高光
                                    cherishLC
PS
                                    
    方法一、压暗高光&重新着色 
当皮肤很油又使用闪光灯时，很容易在面部形成高光区域。 
下面讲一下我今天处理高光区域的心得： 
皮肤可以分为纹理和色彩两个属性。其中纹理主要由亮度通道（Lab模式的L通道）决定，色彩则由a、b通道确定。 
处理思路为在保持高光区域纹理的情况下，对高光区域着色。具体步骤为：降低高光区域的整体的亮度，再进行着色。 
如果想简化步骤，可以只进行着色（参看下面的步骤1
    
                                
    • 
                                
  • Java VisualVM监控远程JVM
                                    crabdave
visualvm
                                    
    Java VisualVM监控远程JVM  
  
JDK1.6开始自带的VisualVM就是不错的监控工具. 
这个工具就在JAVA_HOME\bin\目录下的jvisualvm.exe, 双击这个文件就能看到界面 
  
通过JMX连接远程机器, 需要经过下面的配置: 
1. 修改远程机器JDK配置文件 (我这里远程机器是linux). 
   
    
                                
    • 
                                
  • Saiku去掉登录模块
                                    daizj
saiku登录olapBI
                                    
     
1、修改applicationContext-saiku-webapp.xml 
 
<security:intercept-url pattern="/rest/**" access="IS_AUTHENTICATED_ANONYMOUSLY" />  
<security:intercept-url pattern=&qu
    
                                
    • 
                                
  • 浅析 Flex中的Focus
                                    dsjt
htmlFlexFlash
                                    
    关键字：focus、 setFocus、 IFocusManager、KeyboardEvent 
 焦点、设置焦点、获得焦点、键盘事件 
 
 
 一、无焦点的困扰——组件监听不到键盘事件 
原因：只有获得焦点的组件（确切说是InteractiveObject）才能监听到键盘事件的目标阶段；键盘事件（flash.events.KeyboardEvent）参与冒泡阶段，所以焦点组件的父项（以及它爸
    
                                
    • 
                                
  • Yii全局函数使用
                                    dcj3sjt126com
yii
                                    
    由于YII致力于完美的整合第三方库，它并没有定义任何全局函数。yii中的每一个应用都需要全类别和对象范围。例如，Yii::app()->user;Yii::app()->params['name'];等等。我们可以自行设定全局函数，使得代码看起来更加简洁易用。(原文地址) 
我们可以保存在globals.php在protected目录下。然后，在入口脚本index.php的，我们包括在
    
                                
    • 
                                
  • 设计模式之单例模式二（解决无序写入的问题）
                                    come_for_dream
单例模式volatile乱序执行双重检验锁
                                    
                    在上篇文章中我们使用了双重检验锁的方式避免懒汉式单例模式下由于多线程造成的实例被多次创建的问题，但是因为由于JVM为了使得处理器内部的运算单元能充分利用，处理器可能会对输入代码进行乱序执行（Out Of Order Execute）优化，处理器会在计算之后将乱序执行的结果进行重组，保证该
    
                                
    • 
                                
  • 程序员从初级到高级的蜕变
                                    gcq511120594
框架工作PHPandroidhtml5
                                    
    软件开发是一个奇怪的行业，市场远远供不应求。这是一个已经存在多年的问题，而且随着时间的流逝，愈演愈烈。 
我们严重缺乏能够满足需求的人才。这个行业相当年轻。大多数软件项目是失败的。几乎所有的项目都会超出预算。我们解决问题的最佳指导方针可以归结为——“用一些通用方法去解决问题，当然这些方法常常不管用，于是，唯一能做的就是不断地尝试，逐个看看是否奏效”。 
现在我们把淫浸代码时间超过3年的开发人员称为
    
                                
    • 
                                
  • Reverse Linked List
                                    hcx2013
list
                                    
    Reverse a singly linked list. 
  
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
p
    
                                
    • 
                                
  • Spring4.1新特性——数据库集成测试
                                    jinnianshilongnian
spring 4.1
                                    
    目录 
Spring4.1新特性——综述 
Spring4.1新特性——Spring核心部分及其他 
Spring4.1新特性——Spring缓存框架增强 
Spring4.1新特性——异步调用和事件机制的异常处理 
Spring4.1新特性——数据库集成测试脚本初始化 
Spring4.1新特性——Spring MVC增强 
Spring4.1新特性——页面自动化测试框架Spring MVC T
    
                                
    • 
                                
  • C# Ajax上传图片同时生成微缩图(附Demo)
                                    liyonghui160com

                                    
      
  
1.Ajax无刷新上传图片,详情请阅我的这篇文章。（jquery + c# ashx） 
        2.C#位图处理  System.Drawing。 
        3.最新demo支持IE7,IE8,Fir
    
                                
    • 
                                
  • Java list三种遍历方法性能比较
                                    pda158
java
                                    
    从c/c++语言转向java开发，学习java语言list遍历的三种方法，顺便测试各种遍历方法的性能，测试方法为在ArrayList中插入1千万条记录，然后遍历ArrayList，发现了一个奇怪的现象，测试代码例如以下： 
package com.hisense.tiger.list;
import java.util.ArrayList;
import java.util.Iterator;
    
                                
    • 
                                
  • 300个涵盖IT各方面的免费资源（上）——商业与市场篇
                                    shoothao
seo商业与市场IT资源免费资源
                                    
     
 A.网站模板+logo+服务器主机+发票生成 
 
 
  HTML5 UP:响应式的HTML5和CSS3网站模板。 
  Bootswatch:免费的Bootstrap主题。 
  Templated:收集了845个免费的CSS和HTML5网站模板。 
  Wordpress.org|Wordpress.com:可免费创建你的新网站。 
  Strikingly:关注领域中免费无限的移动优
    
                                
    • 
                                
  • localStorage、sessionStorage
                                    uule
localStorage
                                    
    W3School 例子 
  
HTML5 提供了两种在客户端存储数据的新方法： 
localStorage - 没有时间限制的数据存储 
sessionStorage - 针对一个 session 的数据存储 
  
之前，这些都是由 cookie 完成的。但是 cookie 不适合大量数据的存储，因为它们由每个对服务器的请求来传递，这使得 cookie 速度很慢而且效率也不
    
                                
    •