一 Maven:
<properties>
<spring.version>5.1.6.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>3.8.1</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>
<exclusions>
<exclusion>
<artifactId>dom4j</artifactId>
<groupId>dom4j</groupId>
</exclusion>
</exclusions>
</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>
<exclusions>
<exclusion>
<artifactId>jboss-logging</artifactId>
<groupId>org.jboss.logging</groupId>
</exclusion>
</exclusions>
</dependency>
<!-- hibernate end -->
<!-- c3p0 beg -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-dbcp2</artifactId>
<version>2.6.0</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>
<exclusions>
<exclusion>
<artifactId>log4j</artifactId>
<groupId>log4j</groupId>
</exclusion>
</exclusions>
</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>
<exclusions>
<exclusion>
<artifactId>spring-beans</artifactId>
<groupId>org.springframework</groupId>
</exclusion>
<exclusion>
<artifactId>spring-core</artifactId>
<groupId>org.springframework</groupId>
</exclusion>
<exclusion>
<artifactId>spring-aop</artifactId>
<groupId>org.springframework</groupId>
</exclusion>
<exclusion>
<artifactId>slf4j-api</artifactId>
<groupId>org.slf4j</groupId>
</exclusion>
<exclusion>
<artifactId>spring-tx</artifactId>
<groupId>org.springframework</groupId>
</exclusion>
<exclusion>
<artifactId>spring-orm</artifactId>
<groupId>org.springframework</groupId>
</exclusion>
<exclusion>
<artifactId>jcl-over-slf4j</artifactId>
<groupId>org.slf4j</groupId>
</exclusion>
<exclusion>
<artifactId>spring-context</artifactId>
<groupId>org.springframework</groupId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.1.6.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>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!-- el end -->
</dependencies>
</project>
二 ApplicationContext.xml 配置:
<?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="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource" ref="dataSource"/>
<!--配置的是扫描的包(实体类所在的包)-->
<property name="packagesToScan" value="cn.xtkj.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"></bean>
</property>
<!--注入jpa的配置信息-
加载jpa的基本配置信息和jpa实现方式(hibernate)的配置信息
create : 每次都会重新创建数据库表
update: 有表不会重新创建,没有表会重新创建表
-->
<property name="jpaProperties">
<props>
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
</bean>
<!--2.创建数据连接池-->
<bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
<property name="username" value="root"></property>
<property name="password" value="root"></property>
<property name="url" value="jdbc:mysql:///jpa?characterEncoding=utf-8"></property>
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
</bean>
<!--3.整合springdatajpa-->
<!--base-package:dao所在的包-->
<jpa:repositories base-package="cn.xtkj.dao" transaction-manager-ref="transactionManager" entity-manager-factory-ref="entityManagerFactory"/>
<!--4.配置事务管理器-->
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory"></property>
</bean>
<!--5声明式事务-->
<!--6.配置包扫描注解(spring)-->
<context:component-scan base-package="cn.xtkj"></context:component-scan>
</beans>
三 实体类的配置
.说明 :1 .Customer类(客户)与 LinkMan(联系人)是一对多的关系
2 Role类(角色) 与 User类 (用户) 是多对多的关系
3.1 Customer类(客户类)
package cn.xtkj.domain;
/*
* 1.实体类和表的映射关系
* @Etity
* @Table
* 2.类中属性和表中字段的映射关系
* @Id
* @GeneratedValue
* @Column
*
* */
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
@Entity
@Table(name="cst_customer")//主表:一对多中的一
public class Customer {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name="cust_id")
private Long custId;
@Column(name="cust_address")
private String custAddress;
@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;
// @Column(name="")
// 配置客户和练习人之间的关系(一堆多的关系)
/*
* 使用注解的形式配置多表关系
* 1.声明关系
* @OneToMang:配置 一对多关系
* targetEntity:对方对象的字节码对象
* 2.配置外键(中间表)
* @JoinColumn
* name:外键字段名称
* referencedColumnName:参照主表的主键字段名称
*
* *在客户实体类上(一的一方)添加了外键配置,所以对于客户而言,也具备了维护外键的作用
* */
/*
因为同时操作 一的一方数据 和多的一方数据,在操作一的一方数据时,会多出来一条修改语句 ,所以就不需要
@OneToMany(targetEntity = LinkMan.class)
@JoinColumn(name = "lkm_cust_id",referencedColumnName = "cust_id")//lkm_cust_id从表 cust_id主表
*/
/*
* 放弃外键维护权
* mappedBy:对方配置关系的属性名称
* cascade:配置级联(多以配置到多表的映射关系的注解上面)
* CascadeType.all :所有
* MERGE :更新
* PERSIST : 保存
* REMOVE : 删除*
*
*
* fetch: 配置关联对象的加载方式
* EAGER :立即加载
* LAZY : 延迟加载
* fetch = FetchType.EAGER
* */
@OneToMany(mappedBy = "customer",cascade = CascadeType.ALL)//放弃描述直接参照多的一方的Customer对象中的数据即可
private Set<LinkMan> linkMENs = new HashSet<LinkMan>();
public Set<LinkMan> getLinkMENs() {
return linkMENs;
}
public void setLinkMENs(Set<LinkMan> linkMENs) {
this.linkMENs = linkMENs;
}
public Long getCustId() {
return custId;
}
public void setCustId(Long custId) {
this.custId = custId;
}
public String getCustAddress() {
return custAddress;
}
public void setCustAddress(String custAddress) {
this.custAddress = custAddress;
}
public String getCustIndustry() {
return custIndustry;
}
public void setCustIndustry(String custIndustry) {
this.custIndustry = custIndustry;
}
public String getCustLevel() {
return custLevel;
}
public void setCustLevel(String custLevel) {
this.custLevel = custLevel;
}
public String getCustName() {
return custName;
}
public void setCustName(String custName) {
this.custName = custName;
}
public String getCustPhone() {
return custPhone;
}
public void setCustPhone(String custPhone) {
this.custPhone = custPhone;
}
public String getCustSource() {
return custSource;
}
public void setCustSource(String custSource) {
this.custSource = custSource;
}
@Override
public String toString() {
return "Customer{" +
"custId=" + custId +
", custAddress='" + custAddress + '\'' +
", custIndustry='" + custIndustry + '\'' +
", custLevel='" + custLevel + '\'' +
", custName='" + custName + '\'' +
", custPhone='" + custPhone + '\'' +
", custSource='" + custSource + '\'' +
'}';
}
}
3.2 LinkMan(联系人类)
package cn.xtkj.domain;
/*
* 1.实体类和表的映射关系
* @Etity
* @Table
* 2.类中属性和表中字段的映射关系
* @Id
* @GeneratedValue
* @Column
*
* */
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
@Entity
@Table(name="cst_customer")//主表:一对多中的一
public class Customer {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name="cust_id")
private Long custId;
@Column(name="cust_address")
private String custAddress;
@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;
// @Column(name="")
// 配置客户和练习人之间的关系(一堆多的关系)
/*
* 使用注解的形式配置多表关系
* 1.声明关系
* @OneToMang:配置 一对多关系
* targetEntity:对方对象的字节码对象
* 2.配置外键(中间表)
* @JoinColumn
* name:外键字段名称
* referencedColumnName:参照主表的主键字段名称
*
* *在客户实体类上(一的一方)添加了外键配置,所以对于客户而言,也具备了维护外键的作用
* */
/*
因为同时操作 一的一方数据 和多的一方数据,在操作一的一方数据时,会多出来一条修改语句 ,所以就不需要
@OneToMany(targetEntity = LinkMan.class)
@JoinColumn(name = "lkm_cust_id",referencedColumnName = "cust_id")//lkm_cust_id从表 cust_id主表
*/
/*
* 放弃外键维护权
* mappedBy:对方配置关系的属性名称
* cascade:配置级联(多以配置到多表的映射关系的注解上面)
* CascadeType.all :所有
* MERGE :更新
* PERSIST : 保存
* REMOVE : 删除*
*
*
* fetch: 配置关联对象的加载方式
* EAGER :立即加载
* LAZY : 延迟加载
* fetch = FetchType.EAGER
* */
@OneToMany(mappedBy = "customer",cascade = CascadeType.ALL)//放弃描述直接参照多的一方的Customer对象中的数据即可
private Set<LinkMan> linkMENs = new HashSet<LinkMan>();
public Set<LinkMan> getLinkMENs() {
return linkMENs;
}
public void setLinkMENs(Set<LinkMan> linkMENs) {
this.linkMENs = linkMENs;
}
public Long getCustId() {
return custId;
}
public void setCustId(Long custId) {
this.custId = custId;
}
public String getCustAddress() {
return custAddress;
}
public void setCustAddress(String custAddress) {
this.custAddress = custAddress;
}
public String getCustIndustry() {
return custIndustry;
}
public void setCustIndustry(String custIndustry) {
this.custIndustry = custIndustry;
}
public String getCustLevel() {
return custLevel;
}
public void setCustLevel(String custLevel) {
this.custLevel = custLevel;
}
public String getCustName() {
return custName;
}
public void setCustName(String custName) {
this.custName = custName;
}
public String getCustPhone() {
return custPhone;
}
public void setCustPhone(String custPhone) {
this.custPhone = custPhone;
}
public String getCustSource() {
return custSource;
}
public void setCustSource(String custSource) {
this.custSource = custSource;
}
@Override
public String toString() {
return "Customer{" +
"custId=" + custId +
", custAddress='" + custAddress + '\'' +
", custIndustry='" + custIndustry + '\'' +
", custLevel='" + custLevel + '\'' +
", custName='" + custName + '\'' +
", custPhone='" + custPhone + '\'' +
", custSource='" + custSource + '\'' +
'}';
}
}
3.3 创建Role(角色类)
package cn.xtkj.domain;
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
@Entity
@Table(name="sys_role")
public class Role {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "role_id")
private Long roleID;
@Column(name="role_name")
private String roleName;
//配置多对多关系
/*
@ManyToMany(targetEntity = User.class)
@JoinTable(name= "sy_user_role",
//joinColumns, 当前表在中间表中的外键
joinColumns={@JoinColumn(name="sys_role_id",referencedColumnName = "role_id")},
//inverseJoinColumn,对方对象在中间表的外键
inverseJoinColumns = {@JoinColumn(name="sys_user_id",referencedColumnName = "user_id")}
)*/
@ManyToMany(mappedBy = "roles") //放弃外键维护权 从多的一方的表中 的 该类对象中的映射获得(User中的Role对象 roles) 维护关系。 (* roles 取决于对方映射关系 的属性名称 *)
private Set<User> users=new HashSet<User>();
public Long getRoleID() {
return roleID;
}
public void setRoleID(Long roleID) {
this.roleID = roleID;
}
public String getRoleName() {
return roleName;
}
public void setRoleName(String roleName) {
this.roleName = roleName;
}
public Set<User> getUsers() {
return users;
}
public void setUsers(Set<User> users) {
this.users = users;
}
}
3.4创建User(用户类 )
package cn.xtkj.domain;
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
@Entity
@Table(name = "sys_user")
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "user_id")
private Long userId;
@Column(name = "user_Name")
private String userName;
@Column(name = "user_age")
private Integer age;
/*
* 配置用户到角色的多对多关系
* 配置多对多的映射关系
* 1.声明表关系
* @ManyToMany(targetEntity = Role.class)//多对多
* targetEntity:对方的实体类字节码
*
* 2.配置中间表(包含两个外键)
* @JoinTable
* name: 中间表的名称
* joinColumns:配制当前对象在中间表的外键
* @JoinColumn的数组
* name:外键名
* referencedColumnName:参照的主表的主键名
*
*
*
* */
@ManyToMany(targetEntity = Role.class,cascade = CascadeType.ALL)
@JoinTable(name= "sy_user_role",
//joinColumns, 当前表在中间表中的外键
joinColumns={@JoinColumn(name="sys_user_id",referencedColumnName = "user_id")},
//inverseJoinColumn,对方对象在中间表的外键
inverseJoinColumns = {@JoinColumn(name="sys_role_id",referencedColumnName = "role_id")}
)
private Set<Role> roles =new HashSet<Role>();
public Long getUserId() {
return userId;
}
public void setUserId(Long userId) {
this.userId = userId;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Set<Role> getRoles() {
return roles;
}
public void setRoles(Set<Role> roles) {
this.roles = roles;
}
}