Skip to content

M
my-gitlab-springboot
提交 5b20b241 authored 作者: mry's avatar mry
浏览文件
操作

上传JPA笔记

上级
隐藏空白字符变更
内嵌 并排
正在显示 包含 2631 行增加 和 0 行删除
.gitignore 0 → 100644
浏览文件 @ 5b20b241
### Java template
# Compiled class file
*.class
# Log file
*.log
# BlueJ files
*.ctxt
# Mobile Tools for Java (J2ME)
.mtj.tmp/
# Package Files #
*.jar
*.war
*.nar
*.ear
*.zip
*.tar.gz
*.rar
# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
hs_err_pid*
### Example user template template
### Example user template
# IntelliJ project files
.idea
*.iml
out
gen
### Java template
# Compiled class file
*.class
# Log file
*.log
# BlueJ files
*.ctxt
# Mobile Tools for Java (J2ME)
.mtj.tmp/
# Package Files #
*.jar
*.war
*.nar
*.ear
*.zip
*.tar.gz
*.rar
# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
hs_err_pid*
### Example user template template
### Example user template
# IntelliJ project files
.idea
*.iml
out
gen
JPA/.gitignore 0 → 100644
浏览文件 @ 5b20b241
### Java template
# Compiled class file
*.class
# Log file
*.log
# BlueJ files
*.ctxt
# Mobile Tools for Java (J2ME)
.mtj.tmp/
# Package Files #
*.jar
*.war
*.nar
*.ear
*.zip
*.tar.gz
*.rar
# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
hs_err_pid*
### Example user template template
### Example user template
# IntelliJ project files
.idea
*.iml
out
gen
JPA/pom.xml 0 → 100644
浏览文件 @ 5b20b241
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.jpa</groupId>
<artifactId>JPA</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.hibernate.version>5.0.7.Final</project.hibernate.version>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>${project.hibernate.version}</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-c3p0</artifactId>
<version>${project.hibernate.version}</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.6</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.20</version>
</dependency>
</dependencies>
</project>
\ No newline at end of file
JPA/src/main/java/com/mry/pojo/User.java 0 → 100644
浏览文件 @ 5b20b241
package com.mry.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import javax.persistence.*;
/**
* 客户的实体类
* 需要配置映射关系
* 1.实体类与表的映射关系
* 2.实体类中属性与表中字段的映射关系
* @Entity：声明实体类
* @Table：配置实体类和表的映射关系
* name: 配置数据库表的名称
* 2.实体类中属性与表中字段之间的关系
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
@Entity
@Table(name = "jpa")
public class User {
/**
* @id：声明主键的配置
* @GeneratedValue：配置主键的生成策略
* GenerationType.IDENTITY：自增(底层数据库支持的自动增长方式，对id自增)mysql
* GenerationType.SEQUENCE：序列(底层数据库必须支持序列)oracle
* GenerationType.TABLE：JPA机制，通过一张数据库表的形式帮助我们完成主键自增
* GenerationType.AUTO：程序自动的帮我们选择主键自增策略
* @Column：配置属性和字段的映射关系
* name: 数据库表中字段的名称
*/
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Integer id; //客户主键ID
@Column(name = "name")
private String name;//姓名
@Column(name = "age")
private Integer age;//年龄
@Column(name = "sex")
private String sex;//性别
}
JPA/src/main/java/com/mry/utils/JpaUtils.java 0 → 100644
浏览文件 @ 5b20b241
package com.mry.utils;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
/**
* 解决耗时问题
*
* 第一次访问,getEntityManager方法，经过静态代码块创建一个factory对象，
* 再调用方法创建一个EntityManager对象
* 第二次访问,getEntityManager方法，直接通过一个已经创建好的factory对象，
* 创建EntityManager对象
*/
public class JpaUtils {
private static EntityManagerFactory factory;
static {
factory = Persistence.createEntityManagerFactory("myJpa");
}
/**
* 获取EntityManager实体类对象
*/
public static EntityManager getEntityManager(){
return factory.createEntityManager();
}
}
JPA/src/main/java/com/mry/utils/MyJpaUtils.java 0 → 100644
浏览文件 @ 5b20b241
//package com.mry.utils;
//
//import javax.persistence.EntityManager;
//import javax.persistence.EntityManagerFactory;
//import javax.persistence.Persistence;
//
//public class MyJpaUtils {
//
// private static EntityManagerFactory factory;
//
// static {
// factory = Persistence.createEntityManagerFactory("myJpa");
// }
//
// public static EntityManager EntityManager(){
// return factory.createEntityManager();
// }
//}
JPA/src/main/resources/META-INF/persistence.xml 0 → 100644
浏览文件 @ 5b20b241
<?xml version="1.0" encoding="UTF-8" ?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
<!--需要配置persistence-unit节点
持久化单元：
name: 持久化单元名称
transaction-type：事务管理的方式
JTA: 分布式事务管理
RESOURCE_LOCAL: 本地事务管理
-->
<persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
<!--JPA的实现方式-->
<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
<properties>
<!--数据库信息
用户名: javax.persistence.jdbc.user
密码: javax.persistence.jdbc.password
驱动: javax.persistence.jdbc.driver
数据库地址: javax.persistence.jdbc.url
-->
<property name="javax.persistence.jdbc.user" value="root"/>
<property name="javax.persistence.jdbc.password" value="root"/>
<property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
<property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/jpa"/>
<!--可选择配置：为了配置实现放的配置信息(hibernate)
显示sql: hibernate.show_sql
自动创建数据库表: hibernate.hbm2ddl.auto
create: 程序运行时创建数据库表(如果有表先删除表在创建)
update: 程序运行时创建表(如果有表不会创建表)
none: 不会创建表
-->
<property name="hibernate.show_sql" value="true"/>
<property name="hibernate.hbm2ddl.auto" value="update"/>
</properties>
</persistence-unit>
</persistence>
\ No newline at end of file
JPA/src/test/java/com/mry/JpaTest.java 0 → 100644
浏览文件 @ 5b20b241
package com.mry;
import com.mry.pojo.User;
import com.mry.utils.JpaUtils;
import org.junit.Test;
import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
public class JpaTest {
/**
* 测试JPA的保存
* 案例：保存一个客户到数据库中
* JPA的操作步骤：
* 1.加载配置文件创建工厂(实体管理类工厂)对象
* 2.通过实体管理类工厂获取实体管理器
* 3***.获取事务对象，开启事务
* 4.完成增删改查操作
* 5.提交事务(回滚事务)
* 6.释放资源
*/
@Test
public void testSave(){
// //1.加载配置文件
// EntityManagerFactory factory =
// Persistence.createEntityManagerFactory("myJpa");
// //2.获取实体管理器
// EntityManager em = factory.createEntityManager();
EntityManager em = JpaUtils.getEntityManager();
//3.获取事务
EntityTransaction tx = em.getTransaction();//获取事务对象
tx.begin();//开启事务
//4.完成增删改查操作，保存一个客户到数据库中
User user = new User();
user.setName("滴滴滴");
user.setAge(123);
user.setSex("男");
em.persist(user);//保存操作
//5.提交事务
tx.commit();
//6.释放资源
em.close();
// factory.close();
}
/**
* find方法查询，
* 1.查询的对象就是当前的客户对象本身
* 2.在调用find方法的时候，就发送SQL语句查询数据库
*/
@Test
public void testFind(){
//1.通过工具类获取EntityManager
EntityManager em = JpaUtils.getEntityManager();
//2.开启事务
EntityTransaction et = em.getTransaction();
et.begin();
//3.CRUD
/**
* find：根据id查询数据
* class:查询数据的结果需要包装的实体类类型的字节码
* id: 查询的主键的取值
* 立即加载：
*/
User user = em.find(User.class, 1);
// System.out.println(user);
//提交事务
et.commit();
//释放资源
em.close();
}
/**
* getReference方法:
* 1.获取的对象是一个动态代理对象
* 2.使用getReference方法不会立即发送sql语句查询数据库
* 当调用查询结果对象的时候，才会发送查询的sql语句
* 什么时候用，什么时候发送
* 延迟加载(懒加载)
* 得到的是一个动态代理对象
* 什么时候用，什么时候才会查询
* 一般使用延迟加载
*/
@Test
public void testReference(){
//1.加载配置文件获取管理器
EntityManager em = JpaUtils.getEntityManager();
//2.开启事务
EntityTransaction et = em.getTransaction();
et.begin();
//3.业务逻辑
User user = em.getReference(User.class,1);
// System.out.println(user);
//4.提交事务
et.commit();
//5.释放缓存
em.close();
}
@Test
public void testRemove(){
//1.加载配置文件获取管理器
EntityManager entityManager = JpaUtils.getEntityManager();
//2.开启事务
EntityTransaction transaction = entityManager.getTransaction();
transaction.begin();
//3.业务CRUD
//3.1根据ID查询客户，然后删除
User user = entityManager.find(User.class,1);
entityManager.remove(user);
//4.提交事务
transaction.commit();
//5.释放资源
entityManager.close();
}
@Test
public void testUpdate(){
//1.获取配置文件，获取管理器
EntityManager entityManager = JpaUtils.getEntityManager();
//2.开启事务
EntityTransaction transaction = entityManager.getTransaction();
transaction.begin();
//3.业务CRUD，更新操作
User user = entityManager.getReference(User.class, 1);
user.setName("张三");
entityManager.merge(user);
//4.提交事务
transaction.commit();
//5.释放资源
entityManager.close();
}
}
JPA/src/test/java/com/mry/JpqlTest.java 0 → 100644
浏览文件 @ 5b20b241
package com.mry;
import com.mry.utils.JpaUtils;
import org.junit.Test;
import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
import javax.persistence.Query;
import java.util.List;
/**
* jpql语句
* 1.创建query查询对象
* 2.对象参数进行赋值
* 3.查询，并且得到返回结果
*/
public class JpqlTest {
/**
* 查询全部
* jpql: from com.mry.pojo.User
* sql: SELECT * FROM jpa
*/
@Test
public void testFindAll(){
//1.获取EntityManager对象
EntityManager entityManager = JpaUtils.getEntityManager();
//2.开启事务
EntityTransaction transaction = entityManager.getTransaction();
transaction.begin();
//3.CRUD操作
String jpql = "FROM User";
//创建Query查询对象，query对象才是执行jpql的对象
Query query = entityManager.createQuery(jpql);
//发送查询，并且封装结果集
List list = query.getResultList();
for(Object obj : list){
System.out.println(obj);
}
//4.提交事务
transaction.commit();
//5.释放资源
entityManager.close();
}
/**
* 排序查询:
* sql: SELECT * FROM jpa ORDER BY id desc
* jpql: from User order by desc
*/
@Test
public void testOrders() {
//1.获取EntityManager对象
EntityManager entityManager = JpaUtils.getEntityManager();
//2.开启事务
EntityTransaction transaction = entityManager.getTransaction();
transaction.begin();
//3.CRUD操作
String jpql = "from User order by id desc";
//创建Query查询对象，query对象才是执行jpql的对象
Query query = entityManager.createQuery(jpql);
//发送查询，并且封装结果集
List list = query.getResultList();
for(Object obj : list){
System.out.println(obj);
}
//4.提交事务
transaction.commit();
//5.释放资源
entityManager.close();
}
/**
* 统计人数
* sql: SELECT COUNT(id) FROM jpa
* jpql: SELECT COUNT(id) FROM User
*/
@Test
public void testCount() {
//1.获取EntityManager对象
EntityManager entityManager = JpaUtils.getEntityManager();
//2.开启事务
EntityTransaction transaction = entityManager.getTransaction();
transaction.begin();
//3.CRUD操作
String jpql = "SELECT COUNT(id) FROM User";
//1.创建Query查询对象，query对象才是执行jpql的对象
Query query = entityManager.createQuery(jpql);
//发送查询，并且封装结果集
Object o = query.getSingleResult();
System.out.println(o);
//4.提交事务
transaction.commit();
//5.释放资源
entityManager.close();
}
/**
* 分页查询:
* sql: select * from jpa limit ?,?
* jpql: from User
*/
@Test
public void testPaged() {
//1.获取EntityManager对象
EntityManager entityManager = JpaUtils.getEntityManager();
//2.开启事务
EntityTransaction transaction = entityManager.getTransaction();
transaction.begin();
//3.CRUD操作
String jpql = "from User";
//3.1.创建Query查询对象，query对象才是执行jpql的对象
Query query = entityManager.createQuery(jpql);
//3.2对参数赋值
//起始索引
query.setFirstResult(0);
//每页查询条数
query.setMaxResults(4);
//发送查询，并且封装结果集
List list = query.getResultList();
for (Object o : list){
System.out.println(o);
}
//4.提交事务
transaction.commit();
//5.释放资源
entityManager.close();
}
/**
* 条件查询:
* sql: select * from jpa where name like '张%'
* jpql: from User where name like ?
*/
@Test
public void testCondition() {
//1.获取EntityManager对象
EntityManager entityManager = JpaUtils.getEntityManager();
//2.开启事务
EntityTransaction transaction = entityManager.getTransaction();
transaction.begin();
//3.CRUD操作
String jpql = "from User where name like ?";
//3.1创建Query对象
Query query = entityManager.createQuery(jpql);
//3.2query进行赋值
//第一个参数，占位符的索引位置
query.setParameter(1,"张%");
List list = query.getResultList();
for (Object o : list){
System.out.println(o);
}
//4.提交事务
transaction.commit();
//5.释放资源
entityManager.close();
}
@Test
public void test(){
EntityManager entityManager = JpaUtils.getEntityManager();
EntityTransaction transaction = entityManager.getTransaction();
transaction.begin();
transaction.commit();
entityManager.close();
}
}
JPA1/pom.xml 0 → 100644
浏览文件 @ 5b20b241
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.jpa</groupId>
<artifactId>JPA1</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
<spring.version>4.2.4.RELEASE</spring.version>
<hibernate.version>5.0.7.Final</hibernate.version>
<slf4j.version>1.6.6</slf4j.version>
<log4j.version>1.2.12</log4j.version>
<c3p0.version>0.9.1.2</c3p0.version>
<mysql.version>5.1.6</mysql.version>
</properties>
<dependencies>
<!-- junit单元测试 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.9</version>
<scope>test</scope>
</dependency>
<!-- spring beg -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.6.8</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- spring end -->
<!-- hibernate beg -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>${hibernate.version}</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>${hibernate.version}</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
<version>5.2.1.Final</version>
</dependency>
<!-- hibernate end -->
<!-- c3p0 beg -->
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>${c3p0.version}</version>
</dependency>
<!-- c3p0 end -->
<!-- log end -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>${log4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${slf4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${slf4j.version}</version>
</dependency>
<!-- log end -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-jpa</artifactId>
<version>1.9.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>4.2.4.RELEASE</version>
</dependency>
<!-- el beg 使用spring data jpa 必须引入 -->
<dependency>
<groupId>javax.el</groupId>
<artifactId>javax.el-api</artifactId>
<version>2.2.4</version>
</dependency>
<dependency>
<groupId>org.glassfish.web</groupId>
<artifactId>javax.el</artifactId>
<version>2.2.4</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>RELEASE</version>
<scope>compile</scope>
</dependency>
<!-- el end -->
</dependencies>
</project>
\ No newline at end of file
JPA1/src/main/java/cn/itcast/dao/UserDao.java 0 → 100644
浏览文件 @ 5b20b241
package cn.itcast.dao;
import cn.itcast.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import java.util.List;
public interface UserDao extends JpaRepository<User,Integer>, JpaSpecificationExecutor<User> {
/**
* 根据客户名称查询
* 使用jpql形式查询
* jpql: from User where name = ?
*
* 配置jpql语句使用@Query注解
*/
@Query(value = "from User where name = ?1")
public User findJpql(String name);
/**
* 根据客户名称和客户id查询客户
* jpql: from User where name = ? and id = ?
* 默认情况下
* 占位符的位置要与jpql语句的位置相同
* 可以指定位置
* 用?索引的方式，指定站位的取值来源
*/
@Query(value = "from User where name = ?1 and id = ?2")
public User findUserNameAndId(String username, Integer userId);
/**
* 根据ID更新客户的名称
* 更新5号客户的名称，将名称改为张三，男
* sql: update jpa set name = ?,sex = ? where id = ?
* jpql: update User set name = ?1,sex = ?2 where id = ?3
*/
@Query(value = "update User set name = ?1,sex = ?2 where id = ?3")
@Modifying//当前执行的方法是一个更新操作
public void updateUser(String name, String sex, Integer id);
/**
* @Query(value = "")
* value: 可以写jpql也可以写sql
* nativeQuery(默认值为false): false (jpql查询) | true (本地查询sql查询)
*
* 使用sql形式查询
* 查询全部客户
* select * from jpa
*/
@Query(value = "select * from jpa",nativeQuery = true)
public List<User> findSql();
@Query(value = "select * from jpa where name like ?1",nativeQuery = true)
public List<User> findSql1(String name);
/**
* 方法名的约定:
* findBy: 查询
* 对象中的属性名(首字母大写),查询的条件
* findByName: 根据用户名查询
* 在Jpa的运行阶段会根据方法名称进行解析
* 会根据方法名称解析 findBy xxx(实体类)
* 属性名 where name =
*/
public User findByName(String name);
public User findByNameAndAgeAndSex(String name, Integer age,String sex);
/**
* 默认的是=查询，findBy + 属性名称
*
* 模糊查询
* findBy + 属性名 + 查询方式(like | isnull)
*/
public List<User> findByNameLike(String name);
/**
* 多条件查询
* findBy + 属性名 + 查询方式 + 多条件连接符(and|or) + 属性名 + 查询方式
*/
public List<User> findByNameLikeAndAge(String name, Integer age);
}
JPA1/src/main/java/cn/itcast/entity/User.java 0 → 100644
浏览文件 @ 5b20b241
package cn.itcast.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import javax.persistence.*;
@Data
@Accessors(chain = true)
@AllArgsConstructor
@NoArgsConstructor
@Entity
@Table(name = "jpa")
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)//配置主键自增策略
@Column(name = "id")//指定表中字段映射关系
private Integer id;
@Column(name = "name")
private String name;
@Column(name = "age")
private Integer age;
@Column(name = "sex")
private String sex;
}
JPA1/src/main/resources/applicationContext.xml 0 → 100644
浏览文件 @ 5b20b241
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:task="http://www.springframework.org/schema/task"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/data/jpa
http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">
<!-- 1.dataSource 配置数据库连接池-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver" />
<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/jpa" />
<property name="user" value="root" />
<property name="password" value="root" />
</bean>
<!-- 2.配置entityManagerFactory -->
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="packagesToScan" value="cn.itcast.entity" />
<property name="persistenceProvider">
<bean class="org.hibernate.jpa.HibernatePersistenceProvider" />
</property>
<!--JPA的供应商适配器-->
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<property name="generateDdl" value="false" />
<property name="database" value="MYSQL" />
<property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />
<property name="showSql" value="true" />
</bean>
</property>
<property name="jpaDialect">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect" />
</property>
</bean>
<!-- 3.事务管理器-->
<!-- JPA事务管理器 -->
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>
<!-- 整合spring data jpa-->
<jpa:repositories base-package="cn.itcast.dao"
transaction-manager-ref="transactionManager"
entity-manager-factory-ref="entityManagerFactory"></jpa:repositories>
<!-- 4.txAdvice-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="save*" propagation="REQUIRED"/>
<tx:method name="insert*" propagation="REQUIRED"/>
<tx:method name="update*" propagation="REQUIRED"/>
<tx:method name="delete*" propagation="REQUIRED"/>
<tx:method name="get*" read-only="true"/>
<tx:method name="find*" read-only="true"/>
<tx:method name="*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
<!-- 5.aop-->
<aop:config>
<aop:pointcut id="pointcut" expression="execution(* cn.itcast.service.*.*(..))" />
<aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut" />
</aop:config>
<context:component-scan base-package="cn.itcast"></context:component-scan>
<!--组装其它 配置文件-->
</beans>
JPA1/src/test/java/cn/itcast/JpqlTest.java 0 → 100644
浏览文件 @ 5b20b241
package cn.itcast;
import cn.itcast.dao.UserDao;
import cn.itcast.entity.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class JpqlTest {
@Autowired
private UserDao userDao;
@Test
public void findJpql(){
User user = userDao.findJpql("李四");
System.out.println(user);
}
/**
*
*/
@Test
public void findUserNameAndId(){
User user = userDao.findUserNameAndId("李四",2);
System.out.println(user);
}
/**
* 1.更新删除操作，需要手动添加事务
* 2.默认会执行结束之后回滚事务
* @Rollback 是否自动回滚,false不会滚，true需要回滚(默认的)
*/
@Test
@Transactional
@Rollback(value = false)//不要自动回滚
public void updateUser(){
userDao.updateUser("张三","男",5);
}
@Test
public void findSql(){
List<User> list = userDao.findSql();
for (Object obj : list){
System.out.println(obj);
}
}
@Test
public void findSql1(){
List<User> list = userDao.findSql1("张%");
for (Object obj : list){
System.out.println(obj);
}
}
@Test
public void testNaming(){
User user = userDao.findByName("张三");
System.out.println(user);
}
@Test
public void testNameAgeSex(){
User user = userDao.findByNameAndAgeAndSex("张三", 20, "男");
System.out.println(user);
}
@Test
public void testFindByNameLike(){
List<User> list = userDao.findByNameLike("张%");
for (Object obj : list){
System.out.println(obj);
}
}
@Test
public void findByNameLikeAndAge(){
List<User> list = userDao.findByNameLikeAndAge("张%", 20);
for (Object obj : list){
System.out.println(obj);
}
}
}
JPA1/src/test/java/cn/itcast/UserTest.java 0 → 100644
浏览文件 @ 5b20b241
package cn.itcast;
import cn.itcast.dao.UserDao;
import cn.itcast.entity.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class UserTest {
@Autowired
private UserDao userDao;
/**
* 保存用户: 调用调用save()方法
*/
@Test
public void testSave(){
User user = new User();
user.setId(1);
user.setName("hahaha");
userDao.save(user);
}
@Test
public void testUpdate(){
User user = new User();
user.setId(4);
user.setName("狗狗狗");
user.setAge(18);
user.setSex("男");
userDao.save(user);
}
/**
* 根据ID查询
*/
@Test
public void testFindOne(){
User user = userDao.findOne(1);
System.out.println(user);
}
/**
* 删除
*/
@Test
public void testDelete(){
userDao.delete(4);
}
/**
* 测试统计查询
*/
@Test
public void testCount(){
long count = userDao.count();
System.out.println(count);
}
/**
* 判断该id的可和是否存在
* 1.如果为null不存在
* 2.判断数据库中该ID的数量是否为0
*/
@Test
public void testExists(){
boolean exists = userDao.exists(4);
System.out.println(exists);
}
/**
* 根据id从数据库查询
* 懒加载,延迟加载
*/
@Test
@Transactional
public void testGetOne(){
User user = userDao.getOne(1);
System.out.println(user);
}
}
JPA2/pom.xml 0 → 100644
浏览文件 @ 5b20b241
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.jpa</groupId>
<artifactId>JPA2</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<spring.version>4.2.4.RELEASE</spring.version>
<hibernate.version>5.0.7.Final</hibernate.version>
<slf4j.version>1.6.6</slf4j.version>
<log4j.version>1.2.12</log4j.version>
<c3p0.version>0.9.1.2</c3p0.version>
<mysql.version>5.1.6</mysql.version>
</properties>
<dependencies>
<!-- junit单元测试 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.9</version>
<scope>test</scope>
</dependency>
<!-- spring beg -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.6.8</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- spring end -->
<!-- hibernate beg -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>${hibernate.version}</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>${hibernate.version}</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
<version>5.2.1.Final</version>
</dependency>
<!-- hibernate end -->
<!-- c3p0 beg -->
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>${c3p0.version}</version>
</dependency>
<!-- c3p0 end -->
<!-- log end -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>${log4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${slf4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${slf4j.version}</version>
</dependency>
<!-- log end -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-jpa</artifactId>
<version>1.9.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>4.2.4.RELEASE</version>
</dependency>
<!-- el beg 使用spring data jpa 必须引入 -->
<dependency>
<groupId>javax.el</groupId>
<artifactId>javax.el-api</artifactId>
<version>2.2.4</version>
</dependency>
<dependency>
<groupId>org.glassfish.web</groupId>
<artifactId>javax.el</artifactId>
<version>2.2.4</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>RELEASE</version>
<scope>compile</scope>
</dependency>
<!-- el end -->
</dependencies>
</project>
\ No newline at end of file
JPA2/src/main/java/cn/itcast/dao/UserDao.java 0 → 100644
浏览文件 @ 5b20b241
package cn.itcast.dao;
import cn.itcast.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
public interface UserDao extends JpaRepository<User,Integer>, JpaSpecificationExecutor<User> {
}
JPA2/src/main/java/cn/itcast/entity/User.java 0 → 100644
浏览文件 @ 5b20b241
package cn.itcast.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import javax.persistence.*;
@Data
@Accessors(chain = true)
@AllArgsConstructor
@NoArgsConstructor
@Entity
@Table(name = "jpa")
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)//配置主键自增策略
@Column(name = "id")//指定表中字段映射关系
private Integer id;
@Column(name = "name")
private String name;
@Column(name = "age")
private Integer age;
@Column(name = "sex")
private String sex;
}
JPA2/src/main/resources/applicationContext.xml 0 → 100644
浏览文件 @ 5b20b241
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:task="http://www.springframework.org/schema/task"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/data/jpa
http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">
<!-- 1.dataSource 配置数据库连接池-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver" />
<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/jpa" />
<property name="user" value="root" />
<property name="password" value="root" />
</bean>
<!-- 2.配置entityManagerFactory -->
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="packagesToScan" value="cn.itcast.entity" />
<property name="persistenceProvider">
<bean class="org.hibernate.jpa.HibernatePersistenceProvider" />
</property>
<!--JPA的供应商适配器-->
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<property name="generateDdl" value="false" />
<property name="database" value="MYSQL" />
<property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />
<property name="showSql" value="true" />
</bean>
</property>
<property name="jpaDialect">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect" />
</property>
</bean>
<!-- 3.事务管理器-->
<!-- JPA事务管理器 -->
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>
<!-- 整合spring data jpa-->
<jpa:repositories base-package="cn.itcast.dao"
transaction-manager-ref="transactionManager"
entity-manager-factory-ref="entityManagerFactory"></jpa:repositories>
<!-- 4.txAdvice-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="save*" propagation="REQUIRED"/>
<tx:method name="insert*" propagation="REQUIRED"/>
<tx:method name="update*" propagation="REQUIRED"/>
<tx:method name="delete*" propagation="REQUIRED"/>
<tx:method name="get*" read-only="true"/>
<tx:method name="find*" read-only="true"/>
<tx:method name="*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
<!-- 5.aop-->
<aop:config>
<aop:pointcut id="pointcut" expression="execution(* cn.itcast.service.*.*(..))" />
<aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut" />
</aop:config>
<context:component-scan base-package="cn.itcast"></context:component-scan>
<!--组装其它 配置文件-->
</beans>
JPA2/src/test/java/cn/itcast/test/SpecTest.java 0 → 100644
浏览文件 @ 5b20b241
package cn.itcast.test;
import cn.itcast.dao.UserDao;
import cn.itcast.entity.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import javax.persistence.criteria.*;
import java.util.List;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class SpecTest {
@Autowired
private UserDao userDao;
//匿名内部类
/**
* 根据条件，查询单个对象
* 自定义查询条件
* 1.实现Specification借口(提供反省，查询的对象类型)
* 2.实现toPredicate方法(构造查询条件)
* 3.需要借助方法参数中的两个参数(
* root:获取需要查询的对象属性
* CriteriaBuilder: 构造查询条件，内部封装了很多的查询条件(模糊匹配，精准匹配)
* )
* 根据客户名称查询
* 查询条件
* 1.查询方式(精准，模糊)
* criteriaBuilder对象
* 2.比较的属性名称，根据哪个属性，以什么样的方式
* root对象
*/
@Test
public void testSpec1(){
Specification<User> specification = new Specification<User>() {
public Predicate toPredicate(Root<User> root,
CriteriaQuery<?> criteriaQuery,
CriteriaBuilder criteriaBuilder) {
//1.获取比较的属性 要属性名称
Path<Object> name = root.get("name");
//2.构造查询条件 select * from jpa where name = '张三'
Predicate predicate = criteriaBuilder.equal(name, "张三");//进行精准匹配(比较的属性的取值)
return predicate;
}
};
User user = userDao.findOne(specification);
System.out.println(user);
}
/**
* 多条件查询
* 案例： 根据客户名(张三)和客户年龄(20)查询
* root: 获取属性
* 客户名
* 年龄
* criteriaBuilder:
* 1.构造客户名的精准匹配查询
* 2.构造所属行业的精准匹配查询
* 3.将以上两个查询联系起来
*/
@Test
public void testSpec2(){
Specification<User> specification =
new Specification<User>() {
public Predicate toPredicate(Root<User> root,
CriteriaQuery<?> criteriaQuery,
CriteriaBuilder criteriaBuilder) {
//1.构造查询
Path<Object> name = root.get("name");
Path<Object> age = root.get("age");
//2.构造精准查询
Predicate p1 = criteriaBuilder.equal(name, "张三");
Predicate p2 = criteriaBuilder.equal(age, 20);
//3.多个查询条件组合到一起(满足条件1并且满足条件2,满足条件1或条件2)
//and方式拼接多个，or方式拼接多个
Predicate predicate = criteriaBuilder.and(p1, p2);
return predicate;
}
};
User user = userDao.findOne(specification);
System.out.println(user);
}
/**
* 完成柑橘客户名称的模糊查询，返回客户列表
*
* equal: 直接得到path对象(属性)，然后进行比较
* gt.lt.ge.le.like等 : 需要得到path对象，根据path
* 指定比较的参数类型，再去进行比较
* 指定参数类型: path.as(类型的字节码文件)
*/
@Test
public void testSpec3(){
Specification<User> specification = new Specification<User>() {
public Predicate toPredicate(Root<User> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
//1.构造查询条件
Path<Object> name = root.get("name");
//2.查询方式，模糊查询
Predicate like = criteriaBuilder.like(name.as(String.class), "张%");
return like;
}
};
// List<User> list = userDao.findAll(specification);
// for (Object obj : list){
// System.out.println(obj);
// }
//添加排序
//创建排序对象,需要调用构造方法实例化对象
//第一个参数是排序的顺序(倒叙，正序)
//第二个参数排序的属性名
Sort sort = new Sort(Sort.Direction.DESC,"id");
List<User> list = userDao.findAll(specification, sort);
for (User user : list){
System.out.println(user);
}
}
/**
* 分页查询
* specification: 查询条件
* Pageable: 分页参数
* fenecanshu ： 查询的页码，每页多少条数据
* findAll(specification,Pageable)
* page封装好的pageable对象，数据列表，共条数
*/
@Test
public void testSpec4(){
Specification specification = null;
//PageRequest是Pageable的实现类
/**
* 调用的两个参数
* 第一个参数:当前查询的页数
* 第二个参数：每页查询的数量
*/
Pageable pageable = new PageRequest(0,2);
Page<User> page = userDao.findAll(null, pageable);
System.out.println(page.getContent());//得到的数据集合列表
System.out.println(page.getTotalElements());//得到的总条数
System.out.println(page.getTotalPages());//得到的总页数
}
}
JPA3/pom.xml 0 → 100644
浏览文件 @ 5b20b241
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.jpa</groupId>
<artifactId>JPA3</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<spring.version>4.2.4.RELEASE</spring.version>
<hibernate.version>5.0.7.Final</hibernate.version>
<slf4j.version>1.6.6</slf4j.version>
<log4j.version>1.2.12</log4j.version>
<c3p0.version>0.9.1.2</c3p0.version>
<mysql.version>5.1.6</mysql.version>
</properties>
<dependencies>
<!-- junit单元测试 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.9</version>
<scope>test</scope>
</dependency>
<!-- spring beg -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.6.8</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- spring end -->
<!-- hibernate beg -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>${hibernate.version}</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>${hibernate.version}</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
<version>5.2.1.Final</version>
</dependency>
<!-- hibernate end -->
<!-- c3p0 beg -->
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>${c3p0.version}</version>
</dependency>
<!-- c3p0 end -->
<!-- log end -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>${log4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${slf4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${slf4j.version}</version>
</dependency>
<!-- log end -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-jpa</artifactId>
<version>1.9.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>4.2.4.RELEASE</version>
</dependency>
<!-- el beg 使用spring data jpa 必须引入 -->
<dependency>
<groupId>javax.el</groupId>
<artifactId>javax.el-api</artifactId>
<version>2.2.4</version>
</dependency>
<dependency>
<groupId>org.glassfish.web</groupId>
<artifactId>javax.el</artifactId>
<version>2.2.4</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>RELEASE</version>
<scope>compile</scope>
</dependency>
<!-- el end -->
</dependencies>
</project>
\ No newline at end of file
JPA3/src/main/java/cn/itcast/dao/CustomerDao.java 0 → 100644
浏览文件 @ 5b20b241
package cn.itcast.dao;
import cn.itcast.domain.Customer;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
public interface CustomerDao extends JpaRepository<Customer,Long>, JpaSpecificationExecutor<Customer> {
}
JPA3/src/main/java/cn/itcast/dao/LinkManDao.java 0 → 100644
浏览文件 @ 5b20b241
package cn.itcast.dao;
import cn.itcast.domain.LinkMan;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
public interface LinkManDao extends JpaRepository<LinkMan,Long>, JpaSpecificationExecutor<LinkMan> {
}
JPA3/src/main/java/cn/itcast/domain/Customer.java 0 → 100644
浏览文件 @ 5b20b241
package cn.itcast.domain;
import lombok.*;
import lombok.experimental.Accessors;
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
@Entity
@Table(name="cst_customer")
@Getter
@Setter
@Accessors(chain = true)
@AllArgsConstructor
@NoArgsConstructor
public class Customer {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name="cust_id")
private Long custId;
@Column(name="cust_address")
private String custAddress;
@Column(name="cust_industry")
private String custIndustry;
@Column(name="cust_level")
private String custLevel;
@Column(name="cust_name")
private String custName;
@Column(name="cust_phone")
private String custPhone;
@Column(name="cust_source")
private String custSource;
//配置客户和联系人之间的关系(一对多)
//使用注解形式配置多表关系
/**
* 1.声明关系
* @OneToMany 配置一堆多关系
* targetEntity: 对方对象的字节码对象
* 2.配置外键(中间表)
* @JoinColumn 配置外检
* name: 外检字段名称
* referencedColumnName: 参照的主表的主字段名称
*
* 在客户实体类上(一的一方) 添加了外检配置，所以对可和而言也具备了维护外键的作用
*/
/**
* cascade: 配置级联 (可以配置到设置多表的映射关系的注解上)
* CascadeType.ALL :所有
* MERGE :更新
* PERSIST :保存
* REMOVE :删除
* 虽然可以配置但是不推荐使用
* fetch: 配置关联对象的加载方式
* EAGER: 立即加载
* LAZY: 延迟加载(默认的)
*/
//@OneToMany(targetEntity = LinkMan.class)//对方实体类的类型
//@JoinColumn(name = "lkm_cust_id",referencedColumnName = "cust_id")
//放弃维护权 对方控制权限的属性名称
@OneToMany(mappedBy = "customer",cascade = CascadeType.ALL)
private Set<LinkMan> linkMans = new HashSet<LinkMan>();
@Override
public String toString() {
return "Customer{" +
"custId=" + custId +
", custAddress='" + custAddress + '\'' +
", custIndustry='" + custIndustry + '\'' +
", custLevel='" + custLevel + '\'' +
", custName='" + custName + '\'' +
", custPhone='" + custPhone + '\'' +
", custSource='" + custSource + '\'' +
'}';
}
}
JPA3/src/main/java/cn/itcast/domain/LinkMan.java 0 → 100644
浏览文件 @ 5b20b241
package cn.itcast.domain;
import lombok.*;
import lombok.experimental.Accessors;
import javax.persistence.*;
@Entity
@Table(name = "cst_linkman")
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
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;//联系人备注
/**
* 配置联系人到客户的多对一关系
* 使用注解形式配置多对一关系
* 1.配置表关系
* @ManyToOne 配置多对一关系
* targetEntity: 对方的字节码对象
* 2.配置外键(中间表)
* name: 外检字段名称
* referencedColumnName:参照的主表的主字段名称
* 配置外检的过程，配置到了多的一方，就会在多的一方维护外键
*/
@ManyToOne(targetEntity = Customer.class)
@JoinColumn(name = "lkm_cust_id",referencedColumnName = "cust_id")
private Customer customer;
@Override
public String toString() {
return "LinkMan{" +
"lkmId=" + lkmId +
", lkmName='" + lkmName + '\'' +
", lkmGender='" + lkmGender + '\'' +
", lkmPhone='" + lkmPhone + '\'' +
", lkmMobile='" + lkmMobile + '\'' +
", lkmEmail='" + lkmEmail + '\'' +
", lkmPosition='" + lkmPosition + '\'' +
", lkmMemo='" + lkmMemo + '\'' +
'}';
}
}
JPA3/src/main/resources/applicationContext.xml 0 → 100644
浏览文件 @ 5b20b241
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:task="http://www.springframework.org/schema/task"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/data/jpa
http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">
<!--spring 和 spring data jpa的配置-->
<!-- 1.创建entityManagerFactory对象交给spring容器管理-->
<bean id="entityManagerFactoty" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource" ref="dataSource" />
<!--配置的扫描的包（实体类所在的包） -->
<property name="packagesToScan" value="cn.itcast.domain" />
<!-- jpa的实现厂家 -->
<property name="persistenceProvider">
<bean class="org.hibernate.jpa.HibernatePersistenceProvider"/>
</property>
<!--jpa的供应商适配器 -->
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<!--配置是否自动创建数据库表 -->
<property name="generateDdl" value="false" />
<!--指定数据库类型 -->
<property name="database" value="MYSQL" />
<!--数据库方言：支持的特有语法 -->
<property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />
<!--是否显示sql -->
<property name="showSql" value="true" />
</bean>
</property>
<!--jpa的方言 ：高级的特性 -->
<property name="jpaDialect" >
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect" />
</property>
<!--注入jpa的配置信息
加载jpa的基本配置信息和jpa实现方式（hibernate）的配置信息
hibernate.hbm2ddl.auto : 自动创建数据库表
create ： 每次都会重新创建数据库表
update：有表不会重新创建，没有表会重新创建表
-->
<property name="jpaProperties" >
<props>
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
</bean>
<!--2.创建数据库连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="user" value="root"></property>
<property name="password" value="root"></property>
<property name="jdbcUrl" value="jdbc:mysql:///jpa" ></property>
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
</bean>
<!--3.整合spring dataJpa-->
<jpa:repositories base-package="cn.itcast.dao" transaction-manager-ref="transactionManager"
entity-manager-factory-ref="entityManagerFactoty" ></jpa:repositories>
<!--4.配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactoty"></property>
</bean>
<!-- 4.txAdvice-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="save*" propagation="REQUIRED"/>
<tx:method name="insert*" propagation="REQUIRED"/>
<tx:method name="update*" propagation="REQUIRED"/>
<tx:method name="delete*" propagation="REQUIRED"/>
<tx:method name="get*" read-only="true"/>
<tx:method name="find*" read-only="true"/>
<tx:method name="*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
<!-- 5.aop-->
<aop:config>
<aop:pointcut id="pointcut" expression="execution(* cn.itcast.service.*.*(..))" />
<aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut" />
</aop:config>
<!--5.声明式事务 -->
<!-- 6. 配置包扫描-->
<context:component-scan base-package="cn.itcast" ></context:component-scan>
</beans>
\ No newline at end of file
JPA3/src/test/java/cn/itcast/test/ObjectQueryTest.java 0 → 100644
浏览文件 @ 5b20b241
package cn.itcast.test;
import cn.itcast.dao.CustomerDao;
import cn.itcast.dao.LinkManDao;
import cn.itcast.domain.Customer;
import cn.itcast.domain.LinkMan;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
import java.util.Set;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class ObjectQueryTest {
@Autowired
private CustomerDao customerDao;
@Autowired
private LinkManDao linkManDao;
/**
* 通过此对象查询所有的关联对象
*/
@Test
@Transactional
public void testQuery1(){
//查询id为1的客户
Customer customer = customerDao.getOne(1l);
//对象导航查询，此客户下的所有联系人
Set<LinkMan> linkMans = customer.getLinkMans();
for (LinkMan linkMan : linkMans){
System.out.println(linkMan);
}
}
/**
* 对象导航查询:
* 默认使用的是延迟加载的形式查询
* 调用get方法并不会立即发送查询，而是在使用关联对象的时候才会查询
* 修改配置，将延迟加载改为立即加载即可
* fetch:需要配置到多表映射关系的注解上
*/
@Test
@Transactional
public void testQuery2(){
//查询id为1的客户
Customer customer = customerDao.findOne(1l);
//对象导航查询，此客户下的所有联系人
Set<LinkMan> linkMans = customer.getLinkMans();
System.out.println(linkMans.size());
}
/**
* 从联系人对象导航查询他的所属客户
* 从多的到一的一方默认是立即加载
* 延迟加载:
*/
@Test
@Transactional
public void testQuery3(){
LinkMan linkMan = linkManDao.findOne(2l);
//对象导航查询所属客户
Customer customer = linkMan.getCustomer();
System.out.println(customer);
}
}
JPA3/src/test/java/cn/itcast/test/OneToManyTest.java 0 → 100644
浏览文件 @ 5b20b241
package cn.itcast.test;
import cn.itcast.dao.CustomerDao;
import cn.itcast.dao.LinkManDao;
import cn.itcast.domain.Customer;
import cn.itcast.domain.LinkMan;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class OneToManyTest {
@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("张张三");
/**
* 配置了客户到联系人之间的关系
* 从客户的角度上，发送两条insert语句，发送一条更新的数据(更新外检)
*/
customer.getLinkMans().add(linkMan);
customerDao.save(customer);
linkManDao.save(linkMan);
}
@Test
@Transactional
@Rollback(value = 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);
}
@Test
@Transactional
@Rollback(value = false)//设置不自动回滚
public void testAdd2(){
//创建一个客户，创建一个联系人
Customer customer = new Customer();
customer.setCustName("张三");
LinkMan linkMan = new LinkMan();
linkMan.setLkmName("张张三");
/**
* 在一的一放弃维护权
*/
linkMan.setCustomer(customer);
customer.getLinkMans().add(linkMan);
customerDao.save(customer);
linkManDao.save(linkMan);
}
/**
* 级联添加
*/
@Test
@Transactional
@Rollback(value = false)
public void testCascadeAdd(){
//创建一个客户，创建一个联系人
Customer customer = new Customer();
customer.setCustName("张三");
LinkMan linkMan = new LinkMan();
linkMan.setLkmName("张张三");
linkMan.setCustomer(customer);
customer.getLinkMans().add(linkMan);
customerDao.save(customer);
}
/**
* 级联删除
*/
@Test
@Transactional
@Rollback(value = false)
public void testCascadeRemove(){
Customer customer = customerDao.findOne(1l);
customerDao.delete(customer);
}
}
JPA4/pom.xml 0 → 100644
浏览文件 @ 5b20b241
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.jpa</groupId>
<artifactId>JPA4</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<spring.version>4.2.4.RELEASE</spring.version>
<hibernate.version>5.0.7.Final</hibernate.version>
<slf4j.version>1.6.6</slf4j.version>
<log4j.version>1.2.12</log4j.version>
<c3p0.version>0.9.1.2</c3p0.version>
<mysql.version>5.1.6</mysql.version>
</properties>
<dependencies>
<!-- junit单元测试 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.9</version>
<scope>test</scope>
</dependency>
<!-- spring beg -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.6.8</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- spring end -->
<!-- hibernate beg -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>${hibernate.version}</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>${hibernate.version}</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
<version>5.2.1.Final</version>
</dependency>
<!-- hibernate end -->
<!-- c3p0 beg -->
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>${c3p0.version}</version>
</dependency>
<!-- c3p0 end -->
<!-- log end -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>${log4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${slf4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${slf4j.version}</version>
</dependency>
<!-- log end -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-jpa</artifactId>
<version>1.9.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>4.2.4.RELEASE</version>
</dependency>
<!-- el beg 使用spring data jpa 必须引入 -->
<dependency>
<groupId>javax.el</groupId>
<artifactId>javax.el-api</artifactId>
<version>2.2.4</version>
</dependency>
<dependency>
<groupId>org.glassfish.web</groupId>
<artifactId>javax.el</artifactId>
<version>2.2.4</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>RELEASE</version>
<scope>compile</scope>
</dependency>
<!-- el end -->
</dependencies>
</project>
\ No newline at end of file
JPA4/src/main/java/cn/itcast/dao/RoleDao.java 0 → 100644
浏览文件 @ 5b20b241
package cn.itcast.dao;
import cn.itcast.domain.Role;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
public interface RoleDao extends JpaRepository<Role,Long>, JpaSpecificationExecutor<Role> {
}
JPA4/src/main/java/cn/itcast/dao/UserDao.java 0 → 100644
浏览文件 @ 5b20b241
package cn.itcast.dao;
import cn.itcast.domain.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
public interface UserDao extends JpaRepository<User,Long>, JpaSpecificationExecutor<User> {
}
JPA4/src/main/java/cn/itcast/domain/Role.java 0 → 100644
浏览文件 @ 5b20b241
package cn.itcast.domain;
import lombok.*;
import lombok.experimental.Accessors;
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
@Entity
@Table(name = "sys_role")
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
public class Role {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "role_id")
private Long roleId;
@Column(name = "role_name")
private String roleName;
/**
* 配置多对多
*/
@ManyToMany(mappedBy = "roles")
private Set<User> users = new HashSet<User>();
@Override
public String toString() {
return "Role{" +
"roleId=" + roleId +
", roleName='" + roleName + '\'' +
'}';
}
}
JPA4/src/main/java/cn/itcast/domain/User.java 0 → 100644
浏览文件 @ 5b20b241
package cn.itcast.domain;
import lombok.*;
import lombok.experimental.Accessors;
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
@Entity
@Table(name = "sys_user")
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
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)
* 对方的字节码实体类对象
* 2.配置中间表(包含两个外检)
*/
@ManyToMany(targetEntity = Role.class,cascade = CascadeType.ALL)
@JoinTable(name = "sys_user_role",
//当前对象在对象中的外检
joinColumns = {
@JoinColumn(name = "sys_user_id",referencedColumnName = "user_id")},
//对方对象在中间表中的外键
inverseJoinColumns = {
@JoinColumn(name = "sys_role_id",referencedColumnName = "role_id")}
)
private Set<Role> roles = new HashSet<Role>();
@Override
public String toString() {
return "User{" +
"userId=" + userId +
", userName='" + userName + '\'' +
", age=" + age +
'}';
}
}
JPA4/src/main/resources/applicationContext.xml 0 → 100644
浏览文件 @ 5b20b241
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:task="http://www.springframework.org/schema/task"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/data/jpa
http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">
<!--spring 和 spring data jpa的配置-->
<!-- 1.创建entityManagerFactory对象交给spring容器管理-->
<bean id="entityManagerFactoty" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource" ref="dataSource" />
<!--配置的扫描的包（实体类所在的包） -->
<property name="packagesToScan" value="cn.itcast.domain" />
<!-- jpa的实现厂家 -->
<property name="persistenceProvider">
<bean class="org.hibernate.jpa.HibernatePersistenceProvider"/>
</property>
<!--jpa的供应商适配器 -->
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<!--配置是否自动创建数据库表 -->
<property name="generateDdl" value="false" />
<!--指定数据库类型 -->
<property name="database" value="MYSQL" />
<!--数据库方言：支持的特有语法 -->
<property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />
<!--是否显示sql -->
<property name="showSql" value="true" />
</bean>
</property>
<!--jpa的方言 ：高级的特性 -->
<property name="jpaDialect" >
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect" />
</property>
<!--注入jpa的配置信息
加载jpa的基本配置信息和jpa实现方式（hibernate）的配置信息
hibernate.hbm2ddl.auto : 自动创建数据库表
create ： 每次都会重新创建数据库表
update：有表不会重新创建，没有表会重新创建表
-->
<property name="jpaProperties" >
<props>
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
</bean>
<!--2.创建数据库连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="user" value="root"></property>
<property name="password" value="root"></property>
<property name="jdbcUrl" value="jdbc:mysql:///jpa" ></property>
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
</bean>
<!--3.整合spring dataJpa-->
<jpa:repositories base-package="cn.itcast.dao" transaction-manager-ref="transactionManager"
entity-manager-factory-ref="entityManagerFactoty" ></jpa:repositories>
<!--4.配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactoty"></property>
</bean>
<!-- 4.txAdvice-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="save*" propagation="REQUIRED"/>
<tx:method name="insert*" propagation="REQUIRED"/>
<tx:method name="update*" propagation="REQUIRED"/>
<tx:method name="delete*" propagation="REQUIRED"/>
<tx:method name="get*" read-only="true"/>
<tx:method name="find*" read-only="true"/>
<tx:method name="*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
<!-- 5.aop-->
<aop:config>
<aop:pointcut id="pointcut" expression="execution(* cn.itcast.service.*.*(..))" />
<aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut" />
</aop:config>
<!--5.声明式事务 -->
<!-- 6. 配置包扫描-->
<context:component-scan base-package="cn.itcast" ></context:component-scan>
</beans>
\ No newline at end of file
JPA4/src/test/java/cn/itcas/test/ManyToManyTest.java 0 → 100644
浏览文件 @ 5b20b241
package cn.itcas.test;
import cn.itcast.dao.RoleDao;
import cn.itcast.dao.UserDao;
import cn.itcast.domain.Role;
import cn.itcast.domain.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
@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("小王");
//配置用户到角色的关系，可以对中间表中的数据进行维护 1-1
user.getRoles().add(role);
//配置角色到用户的关系，可以对中间表中的数据进行维护 1-1
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("小王");
//配置用户到角色的关系，可以对中间表中的数据进行维护 1-1
user.getRoles().add(role);
//配置角色到用户的关系，可以对中间表中的数据进行维护 1-1
role.getUsers().add(user);
userDao.save(user);
}
/**
* 删除id为1的用户，同事删除他的关联对象，中间表的数据也删除
*/
@Test
@Transactional
@Rollback(value = false)
public void testCasCadeRemove(){
User user = userDao.findOne(1l);
userDao.delete(user);
}
}
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论