h2coder
h2coder

JPA学习记录

JPA是什么

Java Persistence API：用于对象持久化的 API。是Java EE5.0平台中Sun为了统一持久层ORM框架而制定的一套标准，注意是一套标准，而不是具体实现。

JPA和Hibernate的关系

JPA 是 hibernate 的一个抽象（就像JDBC和JDBC驱动的关系）。
JPA 是规范：JPA 本质上就是一种 ORM 规范，不是ORM 框架 ——
因为 JPA 并未提供 ORM 实现，它只是制订了一些规范，提供了一些编程的API接口，但具体实现则由ORM厂商提供实现。
Hibernate 是实现：Hibernate 除了作为 ORM 框架之外，它也是一种JPA实现。
从功能上来说， JPA 是 Hibernate 功能的一个子集。

JPA简单使用

pom文件

主要是Hibernate对JPA的实现依赖，导入它，JPA的规范接口也会连着导入。



    4.0.0

    cn.itcast
    jpa_sample
    1.0-SNAPSHOT

    
        UTF-8
        5.0.7.Final
    

    
        
        
            junit
            junit
            4.12
            test
        

        
        
            org.hibernate
            hibernate-entitymanager
            ${project.hibernate.version}
        

        
        
            org.hibernate
            hibernate-c3p0
            ${project.hibernate.version}
        

        
        
            log4j
            log4j
            1.2.17
        

        
        
            mysql
            mysql-connector-java
            5.1.6

JPA配置文件

在resources目录下，建立一个名为META-INF的文件夹，新建一个名为persistence.xml的文件，META-INF和这个文件名字是固定的。

配置文件主要配置事务类型、JPA的Hibernate实现类、数据库4大要素、以及Hibernate的可选配置



    
    
        
        org.hibernate.jpa.HibernatePersistenceProvider

导入数据库配置

库名：jpa

有5张表，如下：

  • cst_customer：客户表
  • cst_linkman：联系人表
  • sys_role：角色表
  • sys_user：用户表
  • sys_user_role：用户和角色关系中间表

表关系：

  • cst_customer客户表，和cst_linkman联系人表是一对多关系，一个客户可以有多个联系人
  • sys_role角色表，和sys_user用户表是多对多关系，一个用户可以有多个角色

现在简单使用，只用到cst_customer客户表，其他表后面再使用。

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for cst_customer
-- ----------------------------
DROP TABLE IF EXISTS `cst_customer`;
CREATE TABLE `cst_customer` (
  `cust_id` bigint(20) NOT NULL AUTO_INCREMENT,
  `cust_address` varchar(255) DEFAULT NULL,
  `cust_industry` varchar(255) DEFAULT NULL,
  `cust_level` varchar(255) DEFAULT NULL,
  `cust_name` varchar(255) DEFAULT NULL,
  `cust_phone` varchar(255) DEFAULT NULL,
  `cust_source` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`cust_id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of cst_customer
-- ----------------------------
BEGIN;
INSERT INTO `cst_customer` VALUES (1, NULL, 'it教育', 'vip', '传智播客', NULL, NULL);
COMMIT;

-- ----------------------------
-- Table structure for cst_linkman
-- ----------------------------
DROP TABLE IF EXISTS `cst_linkman`;
CREATE TABLE `cst_linkman` (
  `lkm_id` bigint(20) NOT NULL AUTO_INCREMENT,
  `lkm_email` varchar(255) DEFAULT NULL,
  `lkm_gender` varchar(255) DEFAULT NULL,
  `lkm_memo` varchar(255) DEFAULT NULL,
  `lkm_mobile` varchar(255) DEFAULT NULL,
  `lkm_name` varchar(255) DEFAULT NULL,
  `lkm_phone` varchar(255) DEFAULT NULL,
  `lkm_position` varchar(255) DEFAULT NULL,
  `lkm_cust_id` bigint(20) DEFAULT NULL,
  PRIMARY KEY (`lkm_id`),
  KEY `FKh9yp1nql5227xxcopuxqx2e7q` (`lkm_cust_id`),
  CONSTRAINT `FKh9yp1nql5227xxcopuxqx2e7q` FOREIGN KEY (`lkm_cust_id`) REFERENCES `cst_customer` (`cust_id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of cst_linkman
-- ----------------------------
BEGIN;
INSERT INTO `cst_linkman` VALUES (1, NULL, NULL, NULL, NULL, '小王', NULL, NULL, 1);
INSERT INTO `cst_linkman` VALUES (2, NULL, NULL, NULL, NULL, '小李', NULL, NULL, 1);
COMMIT;

-- ----------------------------
-- Table structure for sys_role
-- ----------------------------
DROP TABLE IF EXISTS `sys_role`;
CREATE TABLE `sys_role` (
  `role_id` bigint(20) NOT NULL AUTO_INCREMENT,
  `role_name` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`role_id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of sys_role
-- ----------------------------
BEGIN;
INSERT INTO `sys_role` VALUES (2, 'Java程序员');
INSERT INTO `sys_role` VALUES (3, 'Java程序员');
COMMIT;

-- ----------------------------
-- Table structure for sys_user
-- ----------------------------
DROP TABLE IF EXISTS `sys_user`;
CREATE TABLE `sys_user` (
  `user_id` bigint(20) NOT NULL AUTO_INCREMENT,
  `age` int(11) DEFAULT NULL,
  `user_name` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`user_id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of sys_user
-- ----------------------------
BEGIN;
INSERT INTO `sys_user` VALUES (2, NULL, '小李');
INSERT INTO `sys_user` VALUES (3, NULL, '小李');
COMMIT;

-- ----------------------------
-- Table structure for sys_user_role
-- ----------------------------
DROP TABLE IF EXISTS `sys_user_role`;
CREATE TABLE `sys_user_role` (
  `sys_user_id` bigint(20) NOT NULL,
  `sys_role_id` bigint(20) NOT NULL,
  PRIMARY KEY (`sys_role_id`,`sys_user_id`),
  KEY `FKsbjvgfdwwy5rfbiag1bwh9x2b` (`sys_user_id`),
  CONSTRAINT `FK1ef5794xnbirtsnudta6p32on` FOREIGN KEY (`sys_role_id`) REFERENCES `sys_role` (`role_id`),
  CONSTRAINT `FKsbjvgfdwwy5rfbiag1bwh9x2b` FOREIGN KEY (`sys_user_id`) REFERENCES `sys_user` (`user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of sys_user_role
-- ----------------------------
BEGIN;
INSERT INTO `sys_user_role` VALUES (2, 2);
INSERT INTO `sys_user_role` VALUES (3, 3);
COMMIT;

SET FOREIGN_KEY_CHECKS = 1;

实体类

  • @Entity：声明为数据库表的Entity实体
  • @Table：建立实体类和表的映射关系
  • @Id：配置实体属性为主键字段
  • @GeneratedValue：配置主键的生成策略
    • GenerationType.IDENTITY：自增长，mysql
    • GenerationType.SEQUENCE：序列。要求：数据库必须支持序列，例如oracle，mysql不支持序列
    • GenerationType.TABLE：jpa提供的一种机制，通过一张数据库表的形式帮我们完成自增
    • GenerationType.AUTO：由程序自动帮我们选择主键生成策略，IDENTITY或SEQUENCE
  • @Column：指定实体类属性和数据库表之间的对应关系
    • name：指定数据库表的列名称。
    • unique：是否唯一
    • nullable：是否可以为空
    • inserttable：是否可以插入
    • updateable：是否可以更新
    • columnDefinition: 定义建表时创建此列的DDL
    • secondaryTable: 从表名。如果此列不建在主表上（默认建在主表），该属性定义该列所在从表的名字搭建开发环境[重点]
/**
 * 客户表实体
 * 所有的注解都是使用JPA的规范提供的注解
 * 所以在导入注解包的时候，一定要导入javax.persistence下的
 */
//声明为数据库表的Entity实体
@Entity
//建立实体类和表的映射关系
@Table(name = "cst_customer")
public class Customer {
    //配置为主键
    @Id
    /**
     * 配置主键的生成策略
     *      GenerationType.IDENTITY：自增长，mysql
     *      GenerationType.SEQUENCE：序列
     *          要求：数据库必须支持序列，例如oracle，mysql不支持序列
     *      GenerationType.TABLE：jpa提供的一种机制，通过一张数据库表的形式帮我们完成自增
     *      GenerationType.AUTO：由程序自动帮我们选择主键生成策略，IDENTITY或SEQUENCE
     */
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    /**
     * 指定映射关系
     *
     * 作用：指定实体类属性和数据库表之间的对应关系
     *      属性：
     *          name：指定数据库表的列名称。
     *          unique：是否唯一
     *          nullable：是否可以为空
     *          inserttable：是否可以插入
     *          updateable：是否可以更新
     *          columnDefinition: 定义建表时创建此列的DDL
     *          secondaryTable: 从表名。如果此列不建在主表上（默认建在主表），该属性定义该列所在从表的名字搭建开发环境[重点]
     */
    @Column(name = "cust_id")
    /**
     * 客户编号(主键）
     */
    private Long custId;
    /**
     * 客户名称(公司名称)
     */
    @Column(name = "cust_name")
    private String custName;
    /**
     * 客户信息来源
     */
    @Column(name = "cust_source")
    private String custSource;
    /**
     * 客户所属行业
     */
    @Column(name = "cust_industry")
    private String custIndustry;
    /**
     * 客户级别
     */
    @Column(name = "cust_level")
    private String custLevel;
    /**
     * 客户联系地址
     */
    @Column(name = "cust_address")
    private String custAddress;
    /**
     * 客户联系电话
     */
    @Column(name = "cust_phone")
    private String custPhone;

    //省略get、set、toString方法
}

工具类

Jpa工具类，解决实体管理器工厂浪费资源和耗时问题。

原理：通过静态代码块，第一次访问工具类时，创建一个公共实体管理器工厂，后续通过getEntityManager()方法，获取实体管理器即可。

public class JpaUtil {
    private static EntityManagerFactory factory;

    static {
        //加载配置文件，获取实体管理器工厂
        factory = Persistence.createEntityManagerFactory("myJpa");
    }

    /**
     * 获取实体管理器
     */
    public static EntityManager getEntityManager() {
        return factory.createEntityManager();
    }
}

增删查改

CRUD的步骤都是类似的，只有第四步不同。

  • 步骤：
  1. 加载配置文件，创建实体管理器工厂
  2. 通过实体管理器工厂，获取实体管理器
  3. 获取事务对象，开启事务
  4. 执行增删改
  5. 提交事务或回滚事务
  6. 释放资源

增

/**
 * 测试Jpa的保存
 * 步骤：
 * 1.加载配置文件，创建实体管理器工厂
 * 2.通过实体管理器工厂，获取实体管理器
 * 3.获取事务对象，开启事务
 * 4.执行增删改
 * 5.提交事务或回滚事务
 * 6.释放资源
 */
@Test
public void testSave() {
    //1.加载配置文件，创建实体管理器工厂，传入持久化单元名称
    //EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
    //2.通过实体管理器工厂，获取实体管理器
    //EntityManager entityManager = factory.createEntityManager();

    EntityManager entityManager = JpaUtil.getEntityManager();

    //3.获取事务对象，开启事务
    EntityTransaction tx = entityManager.getTransaction();//获取事务对象
    tx.begin();//开启事务
    //4.执行增删改，保存一个客户到数据库
    Customer customer = new Customer();
    customer.setCustName("传智播客");
    customer.setCustIndustry("教育");
    //保存操作
    entityManager.persist(customer);
    //5.提交事务
    tx.commit();
    //6.释放资源
    entityManager.close();
    //factory.close();
}

删

/**
 * 测试删除
 */
@Test
public void testRemove() {
    //1.获取EntityManager
    EntityManager entityManager = JpaUtil.getEntityManager();
    //2.开启事务
    EntityTransaction tx = entityManager.getTransaction();
    tx.begin();
    //3.执行操作
    //先查询
    Customer customer = entityManager.find(Customer.class, 3L);
    //再删除
    entityManager.remove(customer);
    System.out.println(customer);
    //4.提交事务
    tx.commit();
    //5.释放资源
    entityManager.close();
}

查

查询有2种，find()和getReference()

  • find()
    • 查询对象就是当前客户对象本身
    • 在调用find()方法时，就会发送sql语句
  • getReference()
    • 获取的对象是一个动态代理对象
    • 调用getReference()方法，不会立即发送sql语句查询数据库
    • 当调用查询结果对象的属性的时候，才会发送查询sql，什么时候用，什么时候发送sql语句
/**
 * 测试根据Id查询客户，使用find()
 * 使用find()方法进行查询
 * 1.查询对象就是当前客户对象本身
 * 2.在调用find()方法时，就会发送sql语句
 * 

 * 立即加载
 */
@Test
public void testFind() {
    //1.获取EntityManager
    EntityManager entityManager = JpaUtil.getEntityManager();
    //2.开启事务
    EntityTransaction tx = entityManager.getTransaction();
    tx.begin();
    //3.执行操作
    /**
     * find()，根据Id查询数据
     *  1.class：查询数据的结果，封装到哪个实体类
     *  2.id：查询的主键值
     */
    Customer customer = entityManager.find(Customer.class, 3L);
    System.out.println(customer);
    //4.提交事务
    tx.commit();
    //5.释放资源
    entityManager.close();
}

/**
 * 测试根据Id查询客户，使用getReference()
 * 使用使用getReference()方法进行查询
 * 1.获取的对象是一个动态代理对象
 * 2.调用getReference()方法，不会立即发送sql语句查询数据库
 * 3.当调用查询结果对象的属性的时候，才会发送查询sql，什么时候用，什么时候发送sql语句
 * 延迟加载（懒加载）
 */
@Test
public void testReference() {
    //1.获取EntityManager
    EntityManager entityManager = JpaUtil.getEntityManager();
    //2.开启事务
    EntityTransaction tx = entityManager.getTransaction();
    tx.begin();
    //3.执行操作
    /**
     * getReference()，根据Id查询数据
     *  1.class：查询数据的结果，封装到哪个实体类
     *  2.id：查询的主键值
     */
    Customer customer = entityManager.getReference(Customer.class, 3L);
    System.out.println(customer);
    //4.提交事务
    tx.commit();
    //5.释放资源
    entityManager.close();
}

改

/**
 * 测试更新
 */
@Test
public void testUpdate() {
    //1.获取EntityManager
    EntityManager entityManager = JpaUtil.getEntityManager();
    //2.开启事务
    EntityTransaction tx = entityManager.getTransaction();
    tx.begin();
    //3.执行操作
    //先查询
    Customer customer = entityManager.find(Customer.class, 3L);
    customer.setCustIndustry("it教育");
    //再更新
    entityManager.merge(customer);
    System.out.println(customer);
    //4.提交事务
    tx.commit();
    //5.释放资源
    entityManager.close();
}

JPA整合Spring使用

一般我们会配合Spring一起使用，而不会单独使用，所以接下来就整合Spring使用吧。

pom文件

引入Spring相关类库、以及SpringDataJPA。



    4.0.0

    cn.itcast
    spring-jpa
    1.0-SNAPSHOT

    
        UTF-8
        4.2.4.RELEASE
        5.0.7.Final
        1.6.6
        1.2.12
        0.9.1.2
        5.1.6
    

    
        
        
            junit
            junit
            4.9
            test
        

        
        
            org.aspectj
            aspectjweaver
            1.6.8
        

        
            org.springframework
            spring-aop
            ${spring.version}
        

        
            org.springframework
            spring-context
            ${spring.version}
        

        
            org.springframework
            spring-context-support
            ${spring.version}
        

        
            org.springframework
            spring-orm
            ${spring.version}
        

        
            org.springframework
            spring-beans
            ${spring.version}
        

        
            org.springframework
            spring-core
            ${spring.version}
        

        

        
        
            org.hibernate
            hibernate-core
            ${hibernate.version}
        
        
        
            org.hibernate
            hibernate-entitymanager
            ${hibernate.version}
        
        
            org.hibernate
            hibernate-validator
            5.2.1.Final
        
        

        
        
            c3p0
            c3p0
            ${c3p0.version}
        
        

        
        
            log4j
            log4j
            ${log4j.version}
        

        
            org.slf4j
            slf4j-api
            ${slf4j.version}
        

        
            org.slf4j
            slf4j-log4j12
            ${slf4j.version}
        
        

        
            mysql
            mysql-connector-java
            ${mysql.version}
        

        
            org.springframework.data
            spring-data-jpa
            1.9.0.RELEASE
        

        
            org.springframework
            spring-test
            ${spring.version}
        

        
        
            javax.el
            javax.el-api
            2.2.4
        

        
            org.glassfish.web
            javax.el
            2.2.4

Spring配置文件

  1. jpa相关配置，使用LocalContainerEntityManagerFactoryBean，Spring整合后的Bean，以及hibernate特殊配置
  2. 配置数据库4大要素，以及连接池
  3. 配置dao层接口扫描
  4. 配置事务管理器、配置spring声明式事务
  5. 配置Spring AOP
  6. 配置包扫描

实体类

和之前的一样，不再赘述了

Dao层

Customer表的Dao层，Jpa的Dao接口需要继承2个接口，JpaRepository接口，JpaSpecificationExecutor接口。

JpaRepository接口，提供一些基础的查询方法，第一个泛型是实体类的类型，第二个是主键Id的类型。

JpaSpecificationExecutor接口，提供一些支持条件的查询方法，泛型为实体类的类型。

public interface CustomerDao extends JpaRepository, JpaSpecificationExecutor {
}

测试CRUD

JpaRepository接口继承于PagingAndSortingRepository接口，而PagingAndSortingRepository又继承于CrudRepository接口。

CrudRepository接口，提供了一些基础的增删查改，例如findOne()查询一个、save()新增或更新一条记录、delete()删除一条记录等。

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class CustomerDaoTest {
    @Autowired
    private CustomerDao customerDao;

    /**
     * 根据id查询
     */
    @Test
    public void testFindOne() {
        Customer customer = customerDao.findOne(3L);
        System.out.println(customer);
    }

    /**
     * 测试保存
     * save：保存或更新
     * 根据传入的对象是否有id主键属性，如果有，则为更新，如没有就是新增
     * 更新：先查询，再更新
     */
    @Test
    public void testSave() {
        Customer customer = new Customer();
        customer.setCustName("黑马程序员");
        customer.setCustLevel("vip");
        customer.setCustIndustry("it教育");
        customerDao.save(customer);
    }

    /**
     * 更新
     */
    @Test
    public void testUpdate() {
        Customer customer = customerDao.findOne(5L);
        customer.setCustName("黑马程序员2");
        customerDao.save(customer);
    }

    /**
     * 测试删除
     */
    @Test
    public void testDelete() {
        customerDao.delete(3L);
    }

    /**
     * 查询所有
     */
    @Test
    public void testFindAll() {
        List list = customerDao.findAll();
        for (Customer customer : list) {
            System.out.println(customer);
        }
    }

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

    /**
     * 测试，判断id为4的客户是否存在
     */
    @Test
    public void testExists() {
        boolean isExists = customerDao.exists(4L);
        System.out.println(isExists);
    }

    /**
     * 根据id查询
     * 注解@Transactional，作用：保证getOne()正常运行
     *
     * findOne()：使用了em.find()，立即加载
     * getOne()：使用了em.getReference()，延迟加载
     */
    @Test
    @Transactional
    public void testGetOne() {
        Customer customer = customerDao.getOne(4L);
        System.out.println(customer);
    }
}

JPQL

除了基础的ORM操作，在复杂查询中，难免需要自己写SQL，而JPA提供了JPQL给我们查询。

我们在Dao上，加相关注解写上JPQL。

注释写得很清楚，就不再写一遍了，主要是查询操作用JPQL比较多。

public interface CustomerDao extends JpaRepository, JpaSpecificationExecutor {
    /**
     * 简单案例
     * 

     * 使用Jpql语句进行查询
     * jpql：from Customer where custName = ?
     */
    @Query(value = "from Customer where custName = ?")
    Customer findJpql(String custName);

    /**
     * 多占位符案例
     * 

     * 根据客户名称和客户id，查询客户
     * jpql：from Customer where custName = ? and custId = ?
     * 

     * 对于多个占位符参数
     * 赋值的时候，默认情况下，占位符的位置需要和方法参数中的位置保持一致
     * 

     * 可以指定占位符参数的位置
     * ?索引的方式，指定此占位符的取值，例如参数调换位置，from Customer where custName = ?2 and custId = ?1
     */
//    @Query(value = "from Customer where custName = ?2 and custId = ?1")
//    List findCustNameAndId(Long id,String name);
    @Query(value = "from Customer where custName = ? and custId = ?")
    List findCustNameAndId(String name, Long id);

    /**
     * 使用Jpql完成更新数据
     * 

     * 根据id，更新客户的名称
     * 

     * sql：update cust_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
    void updateCustomer(long id, String custName);

    /**
     * 使用sql语句查询
     * sql：select * from cst_customer
     * 

     * 使用sql语句查询，还是使用@Query注解，但需要设置nativeQuery属性为true，代表value中的是sql语句，默认值为false，就是代表是jpql
     * 

     * 注解@Query：配置查询
     * value：sql语句或jpql
     * nativeQuery：查询方式，true为sql，false为jpql
     */
//    @Query(value = "select * from cst_customer", nativeQuery = true)
//    List findSql();
    @Query(value = "select * from cst_customer where cust_name like ?1", nativeQuery = true)
    List findSql(String name);

    /**
     * 约定方式，方法按规则进行命名，就无须使用@Query写语句进行查询
     * findBy开头：查询，后面是对象属性名（首字母大学），查询条件
     * 

     * findByCustName()，根据客户名称查询
     * 

     * 在运行阶段，会根据方法名称进行解析，findBy from xxx（实体类） 属性名称 where custName = ?
     * 

     * 规则：
     *
     * 注意：如果是精准匹配，查询方式可以不写！
     * 1.精确查询：findBy + 属性名称（根据属性名称进行精确匹配的查询，就是=等于）
     * 2.模糊查询：findBy + 属性名称 + 查询方式（Like | isnull），例如：findByCustNameLike
     * 3.多条件查询：
     *      findBy + 属性名 + 查询方式 + 多条件的连接符（and|or） + 属性名 + 查询方式
     */
    Customer findByCustName(String custName);

    /**
     * 模糊查询
     * findBy + 属性名称 + 查询方式（Like | isnull）
     * 模糊查询：findByCustNameLike
     */
    List findByCustNameLike(String custName);

    /**
     * 使用客户名称模糊查询，和客户所属行业精准匹配的查询
     */
    Customer findByCustNameLikeAndCustIndustry(String custName, String custIndustry);
}

测试JPQL

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class JpqlTest {
    @Autowired
    private CustomerDao customerDao;

    /**
     * 测试基本查询
     */
    @Test
    public void testFindJpql() {
        Customer customer = customerDao.findJpql("黑马程序员");
        System.out.println(customer);
    }

    /**
     * 测试多占位符
     */
    @Test
    public void testFindCustNameAndId() {
        List customers = customerDao.findCustNameAndId("小码哥", 4L);
        for (Customer customer : customers) {
            System.out.println(customer);
        }
    }

    /**
     * 测试Jpql的更新操作
     * Spring Data jpa，执行更新、删除操作，必须使用事务，就是添加@Transactional注解
     * 但默认执行完毕后，回滚事务，所以需要手动指定不自动回滚
     * 

     * 注解@Rollback，value值，true自动回滚，false不自动回滚
     */
    @Test
    @Transactional//添加事务支持，否则执行会报错
    @Rollback(value = false)//设置不自动回滚
    public void testUpdateCustomer() {
        customerDao.updateCustomer(5L, "黑马程序员666");
    }

    /**
     * 测试使用sql查询
     */
    @Test
    public void testFindSql() {
        List list = customerDao.findSql("黑马程序员");
        for (Object[] objects : list) {
            System.out.println(Arrays.toString(objects));
        }
    }

    /**
     * 测试，按方法命名规则查询（精确查询）
     */
    @Test
    public void testFindByCustName() {
        Customer customer = customerDao.findByCustName("黑马程序员");
        System.out.println(customer);
    }

    /**
     * 测试，按方法命名规则模糊查询（模糊查询）
     */
    @Test
    public void testFindByCustNameLike() {
        List customers = customerDao.findByCustNameLike("黑马程序员%");
        for (Customer customer : customers) {
            System.out.println(customer);
        }
    }

    /**
     * 测试，使用客户名称模糊查询，和客户所属行业精准匹配的查询（多条件查询）
     */
    @Test
    public void testFindByCustNameLikeAndCustIndustry() {
        Customer customer = customerDao.findByCustNameLikeAndCustIndustry("黑马程序员%", "it教育");
        System.out.println(customer);
    }
}

条件查询

Dao层接口还继承了一个JpaSpecificationExecutor接口，它提供一些条件查询。

主要使用Specification对象作为条件对象，复写toPredicate()方法，其中有2个对象，我们需要了解。

  • Root：获取需要查询的对象属性，通过它可以获取指定key属性的值
  • CriteriaBuilder：构造查询条件的对象（相当于条件构造器），内部封装了很多查询条件（模糊查询、精准匹配）
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class SpecTest {
    @Autowired
    private CustomerDao customerDao;

    /**
     * 根据查询，查询单个对象
     */
    @Test
    public void testSpec1() {
        /**
         * 自定义查询条件，创建Specification实例，复写toPredicate()方法，返回查询条件
         * toPredicate()方法参数解释：
         *  1.Root，获取需要查询的对象属性
         *  2.CriteriaBuilder，构造查询条件的，内部封装了很多查询条件（模糊查询、精准匹配）
         *
         *  需求：根据客户名称查询，查询客户名称为黑马程序员的客户
         *  查询条件
         *      1.查询方式，CriteriaBuilder对象
         *      2.比较的属性名称，root对象
         */
        Specification specification = new Specification() {
            public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb) {
                //1.获取比较的属性
                Path custName = root.get("custName");
                //2.构造查询条件，select * from cst_customer where cust_name = '黑马程序员'
                //进行精确匹配（参数：比较的属性，比较的属性的值）
                return cb.equal(custName, "黑马程序员");
            }
        };
        Customer customer = customerDao.findOne(specification);
        System.out.println(customer);
    }

    /**
     * 多条件查询
     * 需求：根据客户名"黑马程序员"，和客户所属行业（it教育）
     */
    @Test
    public void testSpec2() {
        /**
         * root：获取属性
         *      客户名
         *      所属行业
         * cb：构造查询
         *      1.构造客户名的精准匹配查询
         *      2.构造所属行业的精准匹配查询
         *      3.将以上2个查询联系起来
         */
        Specification specification = new Specification() {
            public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb) {
                //客户名
                Path custName = root.get("custName");
                //所属行业
                Path custIndustry = root.get("custIndustry");
                //构造查询
                Predicate p1 = cb.equal(custName, "黑马程序员");
                Predicate p2 = cb.equal(custIndustry, "it教育");
//                return cb.or(p1, p2);//或关系
                //联合多个查询条件，满足条件1和条件2，与关系
                return cb.and(p1, p2);
            }
        };
        Customer customer = customerDao.findOne(specification);
        System.out.println(customer);
    }

    /**
     * 模糊查询
     * 需求：根据客户的名称模糊匹配，返回客户列表
     * 

     * equal：直接获取path对象，直接传入进行比较即可
     * gt，lt，ge，like：得到path对象，根据path指定比较的参数类型，再去比较
     * 指定参数类型：path.as(类型的字节码对象)；
     */
    @Test
    public void testSpec3() {
        //构造查询条件
        Specification specification = new Specification() {
            public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb) {
                Path custName = root.get("custName");
                return cb.like(custName.as(String.class), "黑马程序员%");
            }
        };
        /**
         * 排序
         *
         * 参数一：
         * Sort.Direction.DESC：倒序
         * Sort.Direction.ASC：正序
         * 参数二：
         * 需要按照排序的字段
         */
        Sort sort = new Sort(Sort.Direction.DESC, "custId");
        List list = customerDao.findAll(specification, sort);
//        List list = customerDao.findAll(specification);
        for (Customer customer : list) {
            System.out.println(customer);
        }
    }

    /**
     * 分页查询
     * 

     * Pageable分页参数
     * findAll(Specification, Pageable)：带有条件的分页
     * findAll(Pageable)：没有条件的分页
     * 

     * 返回Page对象
     * Pageable接口，实现类PageRequest
     * 构造方法：
     * 1.第一个参数：当前查询的页数（从0开始）
     * 2.第二参数：每页查询的数量
     */
    @Test
    public void testSpec4() {
        Page pages = customerDao.findAll(null, new PageRequest(0, 2));
        //获取总条数
        long totalElements = pages.getTotalElements();
        System.out.println("总条数 totalElements：" + totalElements);
        //获取总页数
        int totalPages = pages.getTotalPages();
        System.out.println("总页数 totalPages：" + totalPages);
        //获取数据集合
        List list = pages.getContent();
        System.out.println("数据集合 list：" + list);
    }
}
 
 
一对多查询
 
 
前面提到cst_customer客户表，和cst_linkman联系人表是一对多关系，一个客户可以有多个联系人。
 
 
那么在实体上，就可以表达表之间的关系，Customer客户表实体类、LinkMan联系人表实体类。
 
 
Customer客户表实体类
 
 
主要是linkmans字段，引用它的多个联系人，JPA推荐我们存储多的一方的实体列表，用Set集合存储。
 
 
     
  
  •  
    @OneToMany注解，声明关系，targetEntity对方的实体类类型
     
   
       
    
    • mappedBy属性：放弃维护外键权，指定维护外键的那一方中使用@JoinColumn注解的属性名
      •  
    
    • cascade属性：级联属性（可以配置到设置多表映射关系的注解上） 
     
         
      
      • CascadeType.ALL：所有
        •  
      
      • CascadeType.MERGE：更新
        •  
      
      • CascadeType.PERSIST：保存
         CascadeType.REMOVE：删除
        •  
     
       
      •  
    
    • fetchType：配置关联对象的加载方式 
     
         
      
      • EAGER：立即加载，如果是单个对象，使用立即加载
        •  
      
      • LAZY：延迟加载（懒加载），一般如果是列表，会使用延迟加载
        •  
     
       
      •  
   
     
    •  
  
  •  
    @JoinColumn注解，配置外键，name：外键字段名称，referencedColumnName：参照的主表的主键名称
     
   
       
    
    • 一般让多的一方来使用这个注解，而不会让一的一方来使用，也不会2个同时使用
      •  
   
     
    •  
 
 
 
/**
 * 客户表实体
 * 所有的注解都是使用JPA的规范提供的注解
 * 所以在导入注解包的时候，一定要导入javax.persistence下的
 */
//声明为数据库表的Entity实体
@Entity
//建立实体类和表的映射关系
@Table(name = "cst_customer")
public class Customer {
    //配置为主键
    @Id
    /**
     * 配置主键的生成策略
     *      GenerationType.IDENTITY：自增长，mysql
     *      GenerationType.SEQUENCE：序列
     *          要求：数据库必须支持序列，例如oracle，mysql不支持序列
     *      GenerationType.TABLE：jpa提供的一种机制，通过一张数据库表的形式帮我们完成自增
     *      GenerationType.AUTO：由程序自动帮我们选择主键生成策略，IDENTITY或SEQUENCE
     */
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    /**
     * 指定映射关系
     *
     * 作用：指定实体类属性和数据库表之间的对应关系
     *      属性：
     *          name：指定数据库表的列名称。
     *          unique：是否唯一
     *          nullable：是否可以为空
     *          inserttable：是否可以插入
     *          updateable：是否可以更新
     *          columnDefinition: 定义建表时创建此列的DDL
     *          secondaryTable: 从表名。如果此列不建在主表上（默认建在主表），该属性定义该列所在从表的名字搭建开发环境[重点]
     */
    @Column(name = "cust_id")
    /**
     * 客户编号(主键）
     */
    private Long custId;
    /**
     * 客户名称(公司名称)
     */
    @Column(name = "cust_name")
    private String custName;
    /**
     * 客户信息来源
     */
    @Column(name = "cust_source")
    private String custSource;
    /**
     * 客户所属行业
     */
    @Column(name = "cust_industry")
    private String custIndustry;
    /**
     * 客户级别
     */
    @Column(name = "cust_level")
    private String custLevel;
    /**
     * 客户联系地址
     */
    @Column(name = "cust_address")
    private String custAddress;
    /**
     * 客户联系电话
     */
    @Column(name = "cust_phone")
    private String custPhone;
    /**
     * 一对多关系映射：客户和联系人，一个客户可有多个联系人
     * 

     * 注解@OneToMany：声明关系，targetEntity对方的实体类类型
     * 注解@JoinColumn：配置外键，name：外键字段名称，referencedColumnName：参照的主表的主键名称
     */
    //由于一的一方可以维护外键，会发送多一条update语句，所以放弃维护外键权
//    @OneToMany(targetEntity = LinkMan.class)
    //联系人表的主键lkm_cust_id，引用该表的主键cust_id
//    @JoinColumn(name = "lkm_cust_id", referencedColumnName = "cust_id")

    /**
     * 放弃维护外键权，需要使用mappedBy属性，指定维护外键的那一方中使用@JoinColumn注解的属性名
     *
     * mappedBy属性：对方配置关系的属性名称
     * cascade属性：级联属性（可以配置到设置多表映射关系的注解上）
     *      1.CascadeType.ALL：所有
     *      2.CascadeType.MERGE：更新
     *      3.CascadeType.PERSIST：保存
     *      4.CascadeType.REMOVE：删除
     *
     *  fetchType：配置关联对象的加载方式
     *      1.EAGER：立即加载
     *      2.LAZY：延迟加载（懒加载）
     */
    @OneToMany(mappedBy = "customer", cascade = CascadeType.ALL, fetch = FetchType.EAGER)
    private Set linkmans = new HashSet(0);

    //省略get、set、toString方法
}

 
 
LinkMan联系人表实体类
 
 
主要是customer属性，引用它的客户实体。
 
 
     
  
  •  @ManyToOne：配置多对一关系，targetEntity：对象的实体类的类型
    •  
  
  •  @JoinColumn：配置外键，name：外键名称，referencedColumnName参照的主表的主键名称
    •  
 
 
 
@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;
    /**
     * 联系人性别
     */
    @Column(name = "lkm_gender")
    private String lkmGender;
    /**
     * 联系人办公电话
     */
    @Column(name = "lkm_phone")
    private String lkmPhone;
    /**
     * 联系人手机
     */
    @Column(name = "lkm_mobile")
    private String lkmMobile;
    /**
     * 联系人邮箱
     */
    @Column(name = "lkm_email")
    private String lkmEmail;
    /**
     * 联系人职位
     */
    @Column(name = "lkm_position")
    private String lkmPosition;
    /**
     * 联系人备注
     */
    @Column(name = "lkm_memo")
    private String lkmMemo;
    /**
     * 多对一关系映射：多个联系人对应客户
     * 注解@ManyToOne：配置多对一关系，targetEntity：对象的实体类的类型
     * 注解@JoinColumn，配置外键，name：外键名称，referencedColumnName参照的主表的主键名称
     */
    @ManyToOne(targetEntity = Customer.class, fetch = FetchType.LAZY)
    //外键lkm_cust_id，引用主表的cust_id
    @JoinColumn(name = "lkm_cust_id", referencedColumnName = "cust_id")
    private Customer customer;

    //省略get、set、toString方法
}

 
 
Dao层
 
 
Jpa的Dao接口需要继承2个接口，JpaRepository接口，JpaSpecificationExecutor接口
 
 
客户表Dao层接口
 
 
Customer表的Dao层
 
 
public interface CustomerDao extends JpaRepository, JpaSpecificationExecutor {
}

 
 
联系人表的Dao层
 
 
public interface LinkManDao extends JpaRepository, JpaSpecificationExecutor {
}

 
 
一对多测试
 
 
因为有一对多关系，实体保存时，一的一方，需要加上多的一方的实体列表。
 
 
以及级联操作，例如删除一个客户时，它的所有联系人都一起删除。
 
 
注意：JPA的测试，要加上事务，并且不自动回滚，否则默认是回滚的，虽然方法执行成功了，数据库是看不到效果的。
 
 
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class OneTwoManyTest {
    @Autowired
    private CustomerDao customerDao;
    @Autowired
    private LinkManDao linkManDao;

    /**
     * 测试，保存一个客户，保存一个联系人
     */
    @Test
    @Transactional//配置事务
    @Rollback(value = false)//不自动回滚
    public void testAdd() {
        Customer customer = new Customer();
        customer.setCustName("百度");
        LinkMan linkMan = new LinkMan();
        linkMan.setLkmName("小李");
        //向客户中，添加一个联系人
        //从客户的角度：发送2条insert语句，再发送一条update更新语句，更新外键（由于我们配置了客户到联系人的关系，客户可以对外键进行维护）
        Set linkmans = customer.getLinkmans();
        linkmans.add(linkMan);
        //保存客户
        customerDao.save(customer);
        //保存联系人
        linkManDao.save(linkMan);
    }

    @Test
    @Transactional//配置事务
    @Rollback(value = false)//不自动回滚
    public void testAdd2() {
        Customer customer = new Customer();
        customer.setCustName("百度");
        LinkMan linkMan = new LinkMan();
        linkMan.setLkmName("小李");

        //联系人中，添加一个客户
        //配置联系人到客户的关系，只发送了2条insert语句（由于我们配置了联系人到客户的映射关系（多对一））
        linkMan.setCustomer(customer);

        //保存客户
        customerDao.save(customer);
        //保存联系人
        linkManDao.save(linkMan);
    }

    /**
     * 会有一条多余的update语句
     *  1.由于一的一方可以维护外键，会发送多一条update语句
     *  2.要解决此问题，只需要在一的一方放弃维护权即可
     */
    @Test
    @Transactional//配置事务
    @Rollback(value = false)//不自动回滚
    public void testAdd3() {
        Customer customer = new Customer();
        customer.setCustName("百度");
        LinkMan linkMan = new LinkMan();
        linkMan.setLkmName("小李");

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

        //保存客户
        customerDao.save(customer);
        //保存联系人
        linkManDao.save(linkMan);
    }

    /**
     * 级联添加，保存一个客户的同时，保存客户的所有联系人
     * 需要在操作主体的实体类上，配置cascade
     */
    @Test
    @Transactional//配置事务
    @Rollback(value = false)//不自动回滚
    public void testCascadeAdd() {
        Customer customer = new Customer();
        customer.setCustName("百度1");
        LinkMan linkMan = new LinkMan();
        linkMan.setLkmName("小李1");
        //设置关系
        linkMan.setCustomer(customer);
        customer.getLinkmans().add(linkMan);
        //保存客户，同时保存客户的所有联系人
        customerDao.save(customer);
    }

    /**
     * 级联删除，删除1号客户的同时，删除1号客户的所有联系人
     */
    @Test
    @Transactional//配置事务
    @Rollback(value = false)//不自动回滚
    public void testCascadeRemove() {
        //1.查询1号客户
        Customer customer = customerDao.findOne(1L);
        //2.删除1号客户
        customerDao.delete(customer);
    }
}

 
 
对象导航查询测试
 
 
对象导航查询：查询一个对象时，通过此对象，查询所有关联的对象
 
 
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class ObjectQueryTest {
    @Autowired
    private CustomerDao customerDao;
    @Autowired
    private LinkManDao linkManDao;

    /**
     * 测试对象导航查询（查询一个对象时，通过此对象，查询所有关联的对象）
     * 添加注解@Transactional，解决could not initialize proxy - no Session错误
     */
    @Test
    @Transactional
    public void testQuery1() {
        //查询1号客户
        Customer customer = customerDao.getOne(1L);
        //对象导航查询
        Set linkmans = customer.getLinkmans();
        for (LinkMan linkman : linkmans) {
            System.out.println(linkman);
        }
    }

    /**
     * 对象导航查询
     * 导航到的属性是多的一方（一个集合），默认使用的是延迟加载的形式查询，也就是说调用get()方法并不会立即发送查询，而是在使用关联对象时，才会查询
     * 如果不想延迟加载，我们只需要修改配置，将延迟加载改为立即加载即可
     * fetch：需要配置到多表映射关系的注解上，@OneToMany、@ManyToMany，这里去Customer类中添加
     */
    @Test
    @Transactional
    public void testQuery2() {
        //查询1号客户
        Customer customer = customerDao.findOne(1L);
        //对象导航查询
        Set linkmans = customer.getLinkmans();
        System.out.println(linkmans.size());
    }

    /**
     * 从联系人对象导航到他所属的客户
     * 导航到的属性是一的一方（单个对象属性），默认使用的是立即加载的方式查询
     */
    @Test
    @Transactional
    public void testQuery3() {
        //查询1号客户
        LinkMan linkMan = linkManDao.findOne(1L);
        Customer customer = linkMan.getCustomer();
        System.out.println(customer);
    }
}

 
 
多对多查询
 
 
前面提到，sys_role角色表，和sys_user用户表是多对多关系，一个用户可以有多个角色，那实体类之间是怎么表达的呢？
 
 
Role角色表实体
 
 
     
  
  •  @ManyToMany注解，配置多对多的映射关系 
   
       
    
    • mappedBy属性，放弃维护权，属性值为维护方的属性名
      •  
   
     
    •  
  
  •  @JoinTable注解，配置外键，一般在维护的那一方加 
   
       
    
    • joinColumns属性：当前对象在中间表的外键
      •  
    
    • inverseJoinColumns：对方对象在中间表的外键
      •  
   
     
    •  
 
 
 
@Entity
@Table(name = "sys_role")
public class Role {
    /**
     * 角色Id
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "role_id")
    private Long id;
    /**
     * 角色名称
     */
    @Column(name = "role_name")
    private String roleName;
    /**
     * 配置多对多的映射关系
     */
//    @ManyToMany(targetEntity = User.class)
//    @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")})
    //放弃维护权，mappedBy属性：指定维护方的属性名
    @ManyToMany(mappedBy = "roles")
    private Set users = new HashSet();

    //省略get、set、toString方法
}

 
 
用户表实体
 
 
     
  
  •  @ManyToMany注解：多对多关系 
   
       
    
    • targetEntity属性：代表对方的实体类字节码
      •  
   
     
    •  
  
  •  @JoinTable注解 
   
       
    
    • name属性：中间表的名称
      •  
    
    • joinColumns属性（数组）： 
     
         
      
      • name：配置当前对象在中间表的外键
        •  
      
      • referencedColumnName：参照的主表的主键名
        •  
     
       
      •  
    
    • inverseJoinColumns属性（数组）：配置对象对象在中间表的位置 
     
         
      
      • name：配置当前对象在中间表的外键
        •  
      
      • referencedColumnName：参照的主表的主键名
        •  
     
       
      •  
   
     
    •  
 
 
 
@Entity
@Table(name = "sys_user")
public class User {
    /**
     * 用户Id
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "user_id")
    private Long id;
    /**
     * 用户名称
     */
    @Column(name = "user_name")
    private String userName;
    /**
     * 用户年龄
     */
    @Column(name = "age")
    private Integer age;
    /**
     * 配置用户到角色的多对多关系
     * 1.配置多对多的映射关系
     *  注解@ManyToMany：多对多关系，targetEntity：代表对方的实体类字节码
     * 2.配置中间表（包含2个外键）
     *
     * 注解@JoinTable：
     *  name属性：中间表的名称
     *  joinColumns属性（数组）：
     *      name：配置当前对象在中间表的外键
     *      referencedColumnName：参照的主表的主键名
     *  inverseJoinColumns属性（数组）：配置对象对象在中间表的位置
     *      name：配置当前对象在中间表的外键
     *      referencedColumnName：参照的主表的主键名
     */
    @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();

    //省略get、set、toString方法
}

 
 
Dao层接口
 
 
角色表Dao
 
 
public interface RoleDao extends JpaRepository, JpaSpecificationExecutor {
}

 
 
用户表Dao
 
 
public interface UserDao extends JpaRepository, JpaSpecificationExecutor {
}

 
 
多对多测试
 
 
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class ManyToManyTest {
    @Autowired
    private UserDao userDao;
    @Autowired
    private RoleDao roleDao;

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

        //配置用户到角色的关系，可以对中间表的数据进行维护
        user.getRoles().add(role);
        //配置角色到用户的关系，可以对中间表的数据进行维护，2方都可以维护，会导致主键重复，而抛出异常，所以需要有一方放弃维护权
        role.getUsers().add(user);

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

    /**
     * 测试级联添加，保存一个用户的同时，保存用户关联的角色
     */
    @Test
    @Transactional
    @Rollback(value = false)
    public void testCascadeAdd() {
        User user = new User();
        user.setUserName("小李");
        Role role = new Role();
        role.setRoleName("Java程序员");

        //配置用户到角色的关系，可以对中间表的数据进行维护
        user.getRoles().add(role);
        //配置角色到用户的关系，可以对中间表的数据进行维护，2方都可以维护，会导致主键重复，而抛出异常，所以需要有一方放弃维护权
        role.getUsers().add(user);

        userDao.save(user);
    }

    /**
     * 级联删除，删除id为1的用户，同时删除他关联的角色
     */
    @Test
    @Transactional
    @Rollback(value = false)
    public void testCascadeDelete() {
        //查询1号用户
        User user = userDao.findOne(1L);
        //删除1号用户
        userDao.delete(user);
    }
}

 
 
总结
 
 
文章可能描述得不是很清楚，代码我上传到了Github，有兴趣的同学，可以clone。
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(JPA学习记录)

        

            

                
    
                    
  • 回溯 Leetcode 332 重新安排行程
                        mmaerd
Leetcode刷题学习记录leetcode算法职场和发展
                        
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
    
                    
    • 
                    
  • 博客网站制作教程
                        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
    
                    
    • 
                    
  • SQLite的入门级项目学习记录（二）
                        深蓝海拓
SQLite学习笔记sqlite学习数据库
                        
    再补充一些基础知识：并行操作的问题1、可以多游标同时运行SQLite，对于同一个连接sqlite3.connect(db_file)，可以同时创建多个游标，每个游标都是独立的，可以执行各自的SQL命令序列。importsqlite3#创建数据库连接conn=sqlite3.connect('example.db')#创建第一个游标cursor1=conn.cursor()cursor1.execu
    
                    
    • 
                    
  • Spring Data JPA
                        kjcoder
SpringDataJPA后端
                        
    JPA概述JPA的全称是JavaPersistenceAPI，即Java持久化API，是SUN公司推出的一套基于ORM的规范，内部是由一系列的接口和抽象类构成。JPA规范不干活，真正干活的是依托与它的实现方式(例：hibernate)。搭建环境（需求：保存客户）1.创建maven工程导入坐标org.hibernatehibernate-entitymanager2.需要配置jpa的核心配置文件*位
    
                    
    • 
                    
  • 搭建第一个SpringDataJPA工程
                        码来码去（未来可期）
JavaWebjava
                        
    第一步：创建maven工程，导入maven坐标使用SpringDataJPA，需要整合Spring与SpringDataJPA，并且需要提供JPA的服务提供者hibernate，所以需要导入spring相关坐标，hibernate坐标，数据库驱动坐标等4.2.4.RELEASE5.0.7.Final1.6.61.2.120.9.1.25.1.6junitjunit4.9testorg.aspect
    
                    
    • 
                    
  • RISC-V架构生态及相关学习记录
                        我朝山海而去
risc-v学习
                        
    从网络整理，仅供自己学习_____________________________________________________________________________1.RISC-V架构的两个特性RISC-V，第五代精简指令处理器。RISC-V指令集，可以在理解上类比于主流商用Inter的x86，ARM的指令集，用于CPU读取、翻译从而指挥计算机进行相应操作。它在RISC（基于精简指令
    
                    
    • 
                    
  • ios runtime 简单路由
                        Mjs

                        
    1.协议本路由通过协议方式实现首先定义一个必须实现的方法typedefvoid(^JCompletionHandler)(id_Nullableresult,NSError*_Nullableerror);@protocolJRouteHandler@required+(void)handleRequestWithParameters:(nullableJParameters)parameters
    
                    
    • 
                    
  • 英语心得1
                        小坤的梦呓

                        
    姑且这段学习记录的名字就这么叫吧。现在看了很多学习方面的经验分享，自己也在实践当中。正如贾兄在经验分享中看到的那样，学习英语而不是学习知识。英语是语言，语言是用来说的，既然要说语言，那必然要从听开始。很多原理和道理也不细说了，这个还需要学习很久。我现在要做的就是根据这些经验和自己的感悟去学习，然后加以改进方法，提高学习效率。现在也有给自己定了一个短期的小目标，争取年底或明年初可以考过雅思。至少达到
    
                    
    • 
                    
  • seata基本使用，柚子快报邀请码778899
                        登录成功

                        
    把seata的使用在这里做了一个总结，希望能够帮助到大家。本案例在实施过程中，威哥力求简单明了，希望大家在学习过程中能够掌握其中的每个细节。好了，废话不多说，如果我们要学习seata，首先需要具备如下技术储备：数据库事务的基本知识；maven工具的使用；熟悉SpringCloudAlibaba技术栈；掌握SpringDataJPA简单使用；一.Seata基本概念1.seata是什么Seata是阿里
    
                    
    • 
                    
  • man命令学习记录
                        天南地北飞
linux基础学习学习linux运维
                        
    使用man来查看命令的用法manls想了解Linux命令的用法假设你想查ls命令的更多信息，输入manls，就会打开manpage（man是manual的缩写，因此manpage就是“手册页面”），显示关于ls命令各个方面的信息。通常，manpage是由编写程序的开发人员编写的。使用这个命令并不难，只需要输入man，后面再跟上你想要了解的命令。$manlsLS(1)UserCommandsLS(1
    
                    
    • 
                    
  • 基于spring boot的旅游管理系统
                        鹿屿二向箔
springboot旅游后端
                        
    一个简单的SpringBoot应用的基础结构示例，以及如何设置一个基本的旅游管理系统。这个例子将包含用户注册和登录的基本功能。首先，你需要设置一个新的SpringBoot项目。可以通过SpringInitializr网站（https://start.spring.io/）来快速生成一个基础项目结构，选择必要的依赖项，比如Web、Thymeleaf、SpringDataJPA和MySQLDriver
    
                    
    • 
                    
  • 如何使用JPA自定义更新的sql语句实现对数据表的修改？——SpringDataJpa实现自定义（更新）update语句
                        海海不掉头发
笔记allsqlitesqlintellijideajapjpa
                        
    文章目录前言一、DAO层/Mapper层二、Service业务处理层三、Controller控制层总结前言有的时候我们在后台管理系统中只需要修改一列的数据时，JPA的操作死对所有字段进行修改，这样就不太方便，而且SpringDataJpa的框架没有线程的更新方法，只能调用save()方法实行保存修改的数据。如果不想把其中一列的数据修改的话，那么JPA就会自动把这一列不想修改的数据默认null，并且
    
                    
    • 
                    
  • C语言简单复习(在力扣上刷题）【学习记录】
                        清蒸君
51单片机c语言leetcode
                        
    一、魔术索引在数组A[0...n-1]中，有所谓的魔术索引，满足条件A[i]=i。给定一个有序整数数组，编写一种方法找出魔术索引，若有的话，在数组A中找出一个魔术索引，如果没有，则返回-1。若有多个魔术索引，返回索引值最小的一个。示例1:输入：nums=[0,2,3,4,5]输出：0说明:0下标的元素为0来源：力扣（LeetCode）链接：https://leetcode-cn.com/probl
    
                    
    • 
                    
  • SpringBoot操作GBase8s数据库示例
                        迷你世界～爱丽丝

                        
    SpringBoot+Hibernate(Jpa)操作GBase8s数据库示例GBase8s数据库是国产事务型数据库，目前已在各领域广泛应用，本篇使用当下主流的J2EE框架Springboot集成Hibernate（Jpa），对GBasse8S数据库CRUD操作进行讲解。1.技术点JPA是JAVA标准持久化API，是SUN公司推出的一套基于ORM的规范；Hibernate是对JPA（ORM规范）的
    
                    
    • 
                    
  • 推荐算法学习记录2.2——kaggle数据集的动漫电影数据集推荐算法实践——基于内容的推荐算法、协同过滤推荐
                        萱仔学习自我记录
推荐算法学习pythonmatplotlib开发语言
                        
    1、基于内容的推荐：这种方法根据项的相关信息（如描述信息、标签等）和用户对项的操作行为（如评论、收藏、点赞等）来构建推荐算法模型。它可以直接利用物品的内容特征进行推荐，适用于内容较为丰富的场景。‌#1.基于内容的推荐算法fromsklearn.feature_extraction.textimportTfidfVectorizerfromsklearn.metrics.pairwiseimport
    
                    
    • 
                    
  • SpringData JPA之Respository接口的使用
                        OVA_Won
SpringDatamysqljavaspring
                        
    SpringDataJPA之Respository接口的使用Respository：最顶层的接口也是标志接口，目的是为了统一所有Repository的类型，且能让组件扫描的时候自动识别。准备工作导入JAR包：别忘了导入Junit测试包，否则后面没法单元测试编写Spring和数据库配置文件applicationContext.xml文件com.OVA.pojojdbc.propertiesjdbc.
    
                    
    • 
                    
  • 使用Spring Boot集成Spring Data JPA和单例模式构建库存管理系统
                        潘多编程
java
                        
    引言在企业级应用开发中，数据库操作是非常重要的一环。SpringDataJPA提供了一种简化的方式来进行数据库交互，它使得开发者无需编写复杂的JPA代码就可以完成常见的CRUD操作。此外，设计模式如单例模式可以帮助我们更好地管理和控制对象的创建过程，从而提高系统的性能和可维护性。本文将展示如何结合SpringBoot、SpringDataJPA以及单例模式来构建一个基本的库存管理系统。环境准备在开
    
                    
    • 
                    
  • LeetCode hot 100 学习记录 day 2
                        a77895
leetcode学习算法
                        
    文章目录Integer方法除自身以外数组的乘积缺失的第一个正数参考链接Integer方法由轮转数组到Interger方法、System方法轮转数组：涉及到的方法：System.arraycopy(newArr,0,nums,0,n)nums.assign(newArr.begin(),newArr.end());方法介绍：publicstaticnativevoidarraycopy(Object
    
                    
    • 
                    
  • 学习记录——day43 C++ 异常处理
                        子座
学习
                        
    一、异常处理的格式1、在可能产生异常的地方使用关键字：throw抛出异常2、try{可能会抛出异常的语句}catch(接收异常的形参){处理异常}任何函数在定义时，可以指定能抛出的异常格式如下返回值类型函数名(形参列表)throw(异常类型1，异常类型2，。。。。)定义时throw没有不影响函数体内throw的使用，系统会自动匹配，如果有，内外类型要一致，不能缺少对于一定不会抛出异常的函数，可用n
    
                    
    • 
                    
  • Spring常用中间件
                        贺仙姑
spring中间件java
                        
    1.数据库中间件（1）MySQL:常用的关系型数据库，支持JDBC和JPA。（2）PostgreSQL:功能强大的开源关系型数据库，支持复杂查询。（3）MongoDB:NoSQL数据库，适合存储非结构化数据。（4）Redis:内存数据结构存储，常用于缓存和消息队列。2.消息队列（1）RabbitMQ:开源消息代理，支持多种消息协议，适合异步处理。（2）Kafka:分布式流处理平台，适合处理大规模数
    
                    
    • 
                    
  • 基于Java新媒体运营分析服务平台设计
                        什么任性
java新媒体运营springspringcloudSSM毕业设计html5
                        
    一、引言随着新媒体行业的迅猛发展，内容创作、用户互动、广告投放等数据的分析变得至关重要。一个基于Java的新媒体运营分析服务平台，旨在整合多源数据，通过大数据处理和分析技术，为新媒体运营团队提供全面、实时的运营洞察。本平台设计旨在提高决策效率，优化内容策略，增强用户参与度，并最终提升品牌影响力和变现能力。二、技术栈和框架后端开发：SpringBoot（微服务架构）、SpringDataJPA（数据
    
                    
    • 
                    
  • 9.6学习记录+三场笔试
                        冰榫
学习
                        
    一、去哪儿笔试+挚文集团1.在调度算法中平均等待时间最短的是什么?短作业优先2.给定一个字符串s，最有效的找到其中第一个不重复的字符的方法是?一、使用哈希表创建一个哈希表，用于存储字符及其出现的次数。可以使用编程语言中提供的字典（如Python中的dict）或类似的数据结构。遍历字符串s：对于每个字符，检查它是否在哈希表中。如果不在哈希表中，将其加入哈希表，并将其出现次数初始化为1。如果已经在哈希
    
                    
    • 
                    
  • Groovy入门（有java基础）
                        black_dawn
groovyjava开发语言
                        
    一、基本概念Groovy是一种基于Java虚拟机（JVM）的动态开发语言，旨在扩展Java语法，提供更简洁、灵活和易于使用的编码方式。本文是在会一定java语言开发的基础上进行的对比入门学习记录。1.特点：动态性：Groovy支持动态类型和动态元编程，使得代码更加灵活和易于编写。简洁性：Groovy的语法相对于Java来说更加简洁，可以用更少的代码实现相同的功能。闭包：Groovy提供了强大的闭包
    
                    
    • 
                    
  • java开发记录
                        T_Y9943
java开发语言
                        
    24.9.6记录一下今天学到的注解,主要是@Api注解@Param详解SpringDataJPA查询结果为空时遇到的问题一个高级的java写法将list中3的值保存下来,重点在filter，此外还有map。Listintegers=list.stream().filter(e->e%3!=0).collect(Collectors.toList());Javalist移除元素JAP查询到的结果是P
    
                    
    • 
                    
  • SpringBoot学习（5）Spring boot Jpa使用
                        星河漫漫l
springboot开发语言运维开发学习
                        
    SpringBootJpa介绍首先了解Jpa是什么？Jpa(JavaPersistenceAPI)是Sun官方提出的Java持久化规范。它为Java开发人员提供了一种对象/关联映射工具来管理Java应用中的关系数据。它的出现主要是为了简化现有的持久化开发工作和整合ORM技术，结束现在Hibernate，TopLink，JDO等ORM框架各自为营的局面。值得注意的是，Jpa是在充分吸收了现有Hibe
    
                    
    • 
                    
  • 搭载python环境
                        guluguluduang
学习记录区00000001
                        
    超级小白学习记录搭载python环境一：找官网下载python二：python是否可以在电脑上找到，用cmd打一下python看看是否有弹出三：有弹出直接用，无弹出信息则用环境变量改一下四：环境变量在高级系统设置中，双击系统设置中的path新建一个自己的python文件五：下载geany用于编程，新建一个文件夹叫xx.py。后缀.py可让geany识别出这是个python的文件，以便于让geany
    
                    
    • 
                    
  • 学习记录——语义分割和实例分割的标签结构
                        落叶击球
学习笔记学习人工智能
                        
    语义分割：一张样本，生成一张掩码图像标签。灰度图像，背景亮度为0，每个目标根据分类赋予不同亮度——1，2，3......实现像素级的类别区分，但无法区分个体。实例分割：原理：一张样本，生成一个多通道的Mat矩阵，也就是多张掩码图像叠在一起。每张掩码图负责存储一个类别的目标，亮度只有0和1，通过通道号区分每个类别。同时，每张掩码图内，每个目标拥有ID号（通过增加一个维度实现），负责区分一个类别中的每
    
                    
    • 
                    
  • 开开心心最重要
                        进步记录2020

                        
    1.难得2月9号，10号这两天没什么工作内容，不过我也充分利用了这两天，闲里时间，紧张的学习记录一些文章套路，为以后写文章打下一定的基础，但愿还是有用的吧。毕竟勤能补拙是真理，再加上潜移默化的学习熏陶，估计会有用。2.今天站闲里忙着买了家电，京东3000多点买了空调，拼多多888买了冰箱，三开门的，应该还可以。但愿安装费时候没有什么事情，祝一切顺利。3这两天不知道为什么，神经总是很紧张，也不知道怎
    
                    
    • 
                    
  • 冶金加热炉学习记录11加热制度
                        改善昨天的自己

                        
    11、加热炉的热制度正确选择钢坯加热工艺，不仅要考虑钢坯的加热温度，还应考虑断面上的温度差，即温度的均匀性。加热炉热制度的确定是进行物料加热计算的前提，也是炉子投产后热工操作制度的依据。钢种不同，料坯的形状、尺寸不同，加热炉的热制度亦应有所区别。对压力加工前的钢坯加热炉而言，钢坯的加热制度可分为：一段加热制度、二段加热制度、三段加热制度。一段式加热制度（也称一期加热制度）是把钢坯放在炉温基本上不变
    
                    
    • 
                    
  • Flutter学习记录-基础控件
                        薰舞空

                        
    statelesswidget没有内部状态.Icon、IconButton,和Text都是无状态widget,他们都是StatelessWidget的子类。statefulwidget是动态的.用户可以和其交互(例如输入一个表单、或者移动一个slider滑块),或者可以随时间改变(也许是数据改变导致的UI更新).Checkbox,Radio,Slider,InkWell,Form,andTextF
    
                    
    • 
                                
  • ASM系列五 利用TreeApi 解析生成Class
                                    lijingyao8206
ASM字节码动态生成ClassNodeTreeAPI
                                    
       前面CoreApi的介绍部分基本涵盖了ASMCore包下面的主要API及功能，其中还有一部分关于MetaData的解析和生成就不再赘述。这篇开始介绍ASM另一部分主要的Api。TreeApi。这一部分源码是关联的asm-tree-5.0.4的版本。 
         在介绍前，先要知道一点， Tree工程的接口基本可以完
    
                                
    • 
                                
  • 链表树——复合数据结构应用实例
                                    bardo
数据结构树型结构表结构设计链表菜单排序
                                    
    我们清楚：数据库设计中，表结构设计的好坏，直接影响程序的复杂度。所以，本文就无限级分类（目录）树与链表的复合在表设计中的应用进行探讨。当然，什么是树，什么是链表，这里不作介绍。有兴趣可以去看相关的教材。 
需求简介： 
经常遇到这样的需求，我们希望能将保存在数据库中的树结构能够按确定的顺序读出来。比如，多级菜单、组织结构、商品分类。更具体的，我们希望某个二级菜单在这一级别中就是第一个。虽然它是最后
    
                                
    • 
                                
  • 为啥要用位运算代替取模呢
                                    chenchao051
位运算哈希汇编
                                    
      
  在hash中查找key的时候，经常会发现用&取代%，先看两段代码吧， 
  
  JDK6中的HashMap中的indexFor方法： 
    /**
     * Returns index for hash code h.
     */
    static int indexFor(int h, int length) {

    
                                
    • 
                                
  • 最近的情况
                                    麦田的设计者
生活感悟计划软考想
                                    
          今天是2015年4月27号 
     整理一下最近的思绪以及要完成的任务 
            1、最近在驾校科目二练车，每周四天，练三周。其实做什么都要用心，追求合理的途径解决。为
    
                                
    • 
                                
  • PHP去掉字符串中最后一个字符的方法
                                    IT独行者
PHP字符串
                                    
    今天在PHP项目开发中遇到一个需求，去掉字符串中的最后一个字符 原字符串1,2,3,4,5,6, 去掉最后一个字符","，最终结果为1,2,3,4,5,6 代码如下： 
$str = "1,2,3,4,5,6,";
$newstr = substr($str,0,strlen($str)-1);
echo $newstr; 
    
                                
    • 
                                
  • hadoop在linux上单机安装过程
                                    _wy_
linuxhadoop
                                    
    1、安装JDK 
    jdk版本最好是1.6以上，可以使用执行命令java -version查看当前JAVA版本号，如果报命令不存在或版本比较低，则需要安装一个高版本的JDK，并在/etc/profile的文件末尾，根据本机JDK实际的安装位置加上以下几行： 
   export JAVA_HOME=/usr/java/jdk1.7.0_25  
    
                                
    • 
                                
  • JAVA进阶----分布式事务的一种简单处理方法
                                    无量
多系统交互分布式事务
                                    
    每个方法都是原子操作： 
 
提供第三方服务的系统，要同时提供执行方法和对应的回滚方法 
 
A系统调用B,C,D系统完成分布式事务 
 
 
=========执行开始======== 
A.aa(); 
 
try { 
 B.bb(); 
} catch(Exception e) { 
 A.rollbackAa(); 
} 
 
try { 
 C.cc(); 
} catch(Excep
    
                                
    • 
                                
  • 安墨移动广 告：移动DSP厚积薄发 引领未来广 告业发展命脉
                                    矮蛋蛋
hadoop互联网
                                    
    　　“谁掌握了强大的DSP技术，谁将引领未来的广 告行业发展命脉。”2014年，移动广 告行业的热点非移动DSP莫属。各个圈子都在纷纷谈论，认为移动DSP是行业突破点，一时间许多移动广 告联盟风起云涌，竞相推出专属移动DSP产品。 
 
　　到底什么是移动DSP呢? 
 
　　DSP(Demand-SidePlatform)，就是需求方平台，为解决广 告主投放的各种需求，真正实现人群定位的精准广 
    
                                
    • 
                                
  • myelipse设置
                                    alafqq
IP
                                    
      在一个项目的完整的生命周期中，其维护费用，往往是其开发费用的数倍。因此项目的可维护性、可复用性是衡量一个项目好坏的关键。而注释则是可维护性中必不可少的一环。 
 
 
 
注释模板导入步骤  
 
 
 
安装方法： 
打开eclipse/myeclipse 
选择 window-->Preferences-->JAVA-->Code-->Code 
    
                                
    • 
                                
  • java数组
                                    百合不是茶
java数组
                                    
    java数组的   声明  创建  初始化；   java支持C语言 
   
  
数组中的每个数都有唯一的一个下标 
  一维数组的定义   声明：  int[] a = new int[3];声明数组中有三个数int[3]    
int[] a 中有三个数，下标从0开始，可以同过for来遍历数组中的数


    
                                
    • 
                                
  • javascript读取表单数据
                                    bijian1013
JavaScript
                                    
    利用javascript读取表单数据，可以利用以下三种方法获取： 
1、通过表单ID属性：var a = document.getElementByIdx_x_x("id"); 
2、通过表单名称属性：var b = document.getElementsByName("name"); 
3、直接通过表单名字获取：var c = form.content.
    
                                
    • 
                                
  • 探索JUnit4扩展：使用Theory
                                    bijian1013
javaJUnitTheory
                                    
    理论机制（Theory） 
一.为什么要引用理论机制（Theory） 
        当今软件开发中，测试驱动开发（TDD — Test-driven development）越发流行。为什么 TDD 会如此流行呢？因为它确实拥有很多优点，它允许开发人员通过简单的例子来指定和表明他们代码的行为意图。 
TDD 的优点： 
    &nb
    
                                
    • 
                                
  • [Spring Data Mongo一]Spring Mongo Template操作MongoDB
                                    bit1129
template
                                    
    什么是Spring Data Mongo 
Spring Data MongoDB项目对访问MongoDB的Java客户端API进行了封装，这种封装类似于Spring封装Hibernate和JDBC而提供的HibernateTemplate和JDBCTemplate，主要能力包括 
1. 封装客户端跟MongoDB的链接管理 
2. 文档-对象映射，通过注解:@Document(collectio
    
                                
    • 
                                
  • 【Kafka八】Zookeeper上关于Kafka的配置信息
                                    bit1129
zookeeper
                                    
    问题： 
1. Kafka的哪些信息记录在Zookeeper中 2. Consumer Group消费的每个Partition的Offset信息存放在什么位置 
3. Topic的每个Partition存放在哪个Broker上的信息存放在哪里 
4. Producer跟Zookeeper究竟有没有关系？没有关系！！！ 
  
//consumers、config、brokers、cont
    
                                
    • 
                                
  • java OOM内存异常的四种类型及异常与解决方案
                                    ronin47
java OOM 内存异常
                                    
          　OOM异常的四种类型： 
　　　 
　　一：　StackOverflowError ：通常因为递归函数引起（死递归，递归太深）。-Xss 128k 一般够用。 
  
  　  二：　out Of memory: PermGen Space：通常是动态类大多，比如web 服务器自动更新部署时引起。-Xmx
    
                                
    • 
                                
  • java-实现链表反转-递归和非递归实现
                                    bylijinnan
java
                                    
    20120422更新： 
对链表中部分节点进行反转操作，这些节点相隔k个： 
0->1->2->3->4->5->6->7->8->9 
k=2 
8->1->6->3->4->5->2->7->0->9 
注意1 3 5 7 9 位置是不变的。 
解法： 
将链表拆成两部分： 
a.0-&
    
                                
    • 
                                
  • Netty源码学习-DelimiterBasedFrameDecoder
                                    bylijinnan
javanetty
                                    
     看DelimiterBasedFrameDecoder的API，有举例： 
 接收到的ChannelBuffer如下： 
 
 +--------------+
 | ABC\nDEF\r\n |
 +--------------+ 
 经过DelimiterBasedFrameDecoder(Delimiters.lineDelimiter())之后，得到： 
 
 +-----+----
    
                                
    • 
                                
  • linux的一些命令 -查看cc攻击-网口ip统计等
                                    hotsunshine
linux
                                    
    Linux判断CC攻击命令详解 
2011年12月23日 ⁄ 安全 ⁄ 暂无评论 
查看所有80端口的连接数 
 
 
netstat -nat|grep -i '80'|wc -l
对连接的IP按连接数量进行排序

netstat -ntu | awk '{print $5}' | cut -d: -f1 | sort | uniq -c | sort -n
查看TCP连接状态

n
    
                                
    • 
                                
  • Spring获取SessionFactory
                                    ctrain
sessionFactory
                                    
    
String sql = "select sysdate from dual";
		
WebApplicationContext wac = ContextLoader.getCurrentWebApplicationContext(); 
String[] names = wac.getBeanDefinitionNames();
for(int i=0; i&
    
                                
    • 
                                
  • Hive几种导出数据方式
                                    daizj
hive数据导出
                                    
    Hive几种导出数据方式 
     
1.拷贝文件 
  
如果数据文件恰好是用户需要的格式，那么只需要拷贝文件或文件夹就可以。 
hadoop fs –cp source_path target_path 
  
2.导出到本地文件系统 
  
--不能使用insert into local directory来导出数据，会报错 
--只能使用
    
                                
    • 
                                
  • 编程之美
                                    dcj3sjt126com
编程PHP重构
                                    
    我个人的 PHP 编程经验中，递归调用常常与静态变量使用。静态变量的含义可以参考 PHP 手册。希望下面的代码，会更有利于对递归以及静态变量的理解 
  
header("Content-type: text/plain");
function static_function () {
    static $i = 0;
    if ($i++ < 1
    
                                
    • 
                                
  • Android保存用户名和密码
                                    dcj3sjt126com
android
                                    
    转自：http://www.2cto.com/kf/201401/272336.html 
我们不管在开发一个项目或者使用别人的项目，都有用户登录功能，为了让用户的体验效果更好，我们通常会做一个功能，叫做保存用户，这样做的目地就是为了让用户下一次再使用该程序不会重新输入用户名和密码，这里我使用3种方式来存储用户名和密码 
1、通过普通 的txt文本存储 
2、通过properties属性文件进行存
    
                                
    • 
                                
  • Oracle 复习笔记之同义词
                                    eksliang
Oracle 同义词Oracle synonym
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2098861 
1.什么是同义词 
      同义词是现有模式对象的一个别名。 
      概念性的东西，什么是模式呢？创建一个用户，就相应的创建了 一个模式。模式是指数据库对象，是对用户所创建的数据对象的总称。模式对象包括表、视图、索引、同义词、序列、过
    
                                
    • 
                                
  • Ajax案例
                                    gongmeitao
Ajaxjsp
                                    
    数据库采用Sql Server2005 
项目名称为:Ajax_Demo 
1.com.demo.conn包 
package com.demo.conn; 
import java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException; 
//获取数据库连接的类public class DBConnec
    
                                
    • 
                                
  • ASP.NET中Request.RawUrl、Request.Url的区别
                                    hvt
.netWebC#asp.nethovertree
                                    
      
如果访问的地址是：http://h.keleyi.com/guestbook/addmessage.aspx?key=hovertree%3C&n=myslider#zonemenu那么Request.Url.ToString() 的值是：http://h.keleyi.com/guestbook/addmessage.aspx?key=hovertree<&
    
                                
    • 
                                
  • SVG 教程 （七）SVG 实例，SVG 参考手册
                                    天梯梦
svg
                                    
    SVG 实例   在线实例 
下面的例子是把SVG代码直接嵌入到HTML代码中。 
谷歌Chrome，火狐，Internet Explorer9，和Safari都支持。 
注意：下面的例子将不会在Opera运行，即使Opera支持SVG - 它也不支持SVG在HTML代码中直接使用。    SVG 实例 
SVG基本形状 
一个圆 
矩形 
不透明矩形 
一个矩形不透明2 
一个带圆角矩
    
                                
    • 
                                
  • 事务管理
                                    luyulong
javaspring编程事务
                                    
    事物管理 
 
spring事物的好处 
 
为不同的事物API提供了一致的编程模型 
支持声明式事务管理 
提供比大多数事务API更简单更易于使用的编程式事务管理API 
整合spring的各种数据访问抽象 
 
TransactionDefinition 
定义了事务策略 
 
int getIsolationLevel()得到当前事务的隔离级别 
 
READ_COMMITTED 
    
                                
    • 
                                
  • 基础数据结构和算法十一：Red-black binary search tree
                                    sunwinner
AlgorithmRed-black
                                    
      
The insertion algorithm for 2-3 trees just described is not difficult to understand; now, we will see that it is also not difficult to implement. We will consider a simple representation known
    
                                
    • 
                                
  • centos同步时间
                                    stunizhengjia
linux集群同步时间
                                    
    做了集群，时间的同步就显得非常必要了。 以下是查到的如何做时间同步。 在CentOS 5不再区分客户端和服务器，只要配置了NTP，它就会提供NTP服务。 1)确认已经ntp程序包： # yum install ntp 2)配置时间源（默认就行，不需要修改） # vi /etc/ntp.conf server pool.ntp.o
    
                                
    • 
                                
  • ITeye 9月技术图书有奖试读获奖名单公布
                                    ITeye管理员
ITeye
                                    
    ITeye携手博文视点举办的9月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。 9月试读活动回顾：http://webmaster.iteye.com/blog/2118112本次技术图书试读活动的优秀奖获奖名单及相应作品如下（优秀文章有很多，但名额有限，没获奖并不代表不优秀）：  
  
  
《NFC：Arduino、Andro
    
                                
    •