HibernanJPA配置

实体类表头配置

@Entity //表示实体类存在

@Table(name="cst_customer") //设置实体类的数据库表名

表里主键ID

@Id //表示主键ID

@Column(name="cust_id") //设置主键ID在数据库中的名子

@GeneratedValue(strategy=GenerationType.IDENTITY) //设置主键ID自增长

 

多对一LinkMan

private Customer cus;

配置

//fetch=FetchType.EAGER XML(lazy="false")立即加载

@ManyToOne(fetch=FetchType.EAGER)立即加载多对一的一表

@JoinColumn(name="外键字段",referencedColumnName="主键表主键字段")

一对多Customer

private Set<LinkMan> mans = new HashSet<LinkMan>()

 

//cascade曾删改查级联起来 mappedBy="cus" 指向一的一方在多的一方中的对象名称然后读取上面多对一配置

@OneToMany(cascade={CascadeType.ALL},mappedBy="cus")

 

多对多（两个表中找到相对一的哪一方配置）

中间表sys_user_role

相对一UserInfo(用户)

private Set<RoleInfo> roles = new HashSet<RoleInfo>();

@ManyToMany(mappedBy="多表实体中创建本表的名字")

相对多RoleInfo（角色）

private Set<UserInfo> users = new HashSet<UserInfo>();

//配置级联操作 默认立即加载

@ManyToMany(cascade={CascadeType.ALL})

//@JoinTable 真对中间表的配置

//name配置中间表名

//@JoinColumns:中间表的外键字段关联当前实体类所对应表的主键字段

//@inverseJoinColumn:中间表的外键字段管理对方的主键字段

@JoinColumn

//name:指定外键字段名称

//referencedColumnName:指定引用主表的主键字段名称

@JoinTable(name="sys_user_role",

joinColumns={@JoinColumn(name="role_id",referencedColumnName="role_id")},

inverseJoinColumns={@JoinColumn(name="user_id",referencedColumnName="user_id")})

 核心配置文件

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence
          http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd"
	version="2.1">
	<!-- JPA的核心配置文件的DTD(XSD)引入 -->
	<!-- JPA持久化单元 主要用于配置数据库信息获取数据库连接 name 因为persistence-unit可以有多个 所以使用name属性进行唯一区分 
		transaction-type="JTA" 设定事务类型 JDBC 操作数据 单线程 JPA JavaEE的数据库操作 多线程 JavaSE的单线程环境 
		JTA(JavaEE多线程) RESOURCE_LOCAL(JavaSE单线程) -->
	<persistence-unit name="myjpa1" transaction-type="RESOURCE_LOCAL">
		<!-- 指定JPA实现框架:Hibnerate,可选 -->
		<provider>org.hibernate.ejb.HibernatePersistence</provider>
		<!-- 指定一下你现在配置的实体类,然后指定好之后jpa才能进行关系 -->
		<class>com.itheima.entity.Customer</class>
		<!-- 配置数据库连接 -->
		<properties>
			<!-- session对象:连接数据库 操作数据库 -->
			<!-- 连接数据库 -->
			<!-- 数据库方言 -->
			<property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect" />
			<!-- 驱动 -->
			<property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver" />
			<!-- url -->
			<property name="hibernate.connection.url"
				value="jdbc:mysql://127.0.0.1:3306/crm_hibernate?characterEncoding=UTF-8" />
			<!-- 用户名 -->
			<property name="hibernate.connection.username" value="root" />
			<!-- 密码 -->
			<property name="hibernate.connection.password" value="root" />

			<!-- 显示执行的SQL语句 把你的SQL语句以一行的行输出到控制台 -->
			<property name="hibernate.show_sql" value="true" />
			<!-- 格式化SQL语句 格式化后进行多行展示 -->
			<property name="hibernate.format_sql" value="true" />

			<!-- 自动管理数据库表结构 -->
			<property name="hibernate.hbm2ddl.auto" value="update" />
			<!-- 配置c3p0 -->
			<property name="hibernate.connection.provider_class"
				value="org.hibernate.connection.C3P0ConnectionProvider" />
		</properties>
	</persistence-unit>
</persistence>

　　JPAUtils包

package com.itheima.util;

import java.sql.Connection;
import java.sql.SQLException;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import org.hibernate.Session;
import org.hibernate.jdbc.Work;

/**
 * JPA获取数据连接的工具类
 * @author sysmaster
 *
 */
public class JPAUtils {
	
	// 创建相关对象 Session? EntityManger(工厂)
	
	// 创建JPA的数据库连接工厂类
	private static EntityManagerFactory factory;
	private static final ThreadLocal<EntityManager> emTL = new ThreadLocal<EntityManager>();
	
	static{
		// 读取配置文件创建工厂对象
		// 为啥不需要找配置文件
		factory = Persistence.createEntityManagerFactory("myjpa1");
	}
	
	
	public static EntityManager getEM(){
		// 创建数据库连接对象
		EntityManager em = null;
		em = emTL.get();
		if(null == em){
			// 创建
			em = factory.createEntityManager();
			// 放入当前线程
			emTL.set(em);
		}
		// 返回
		return em;
	}
	
	
	public static void close(){
		EntityManager em = emTL.get();
		if(null != em){
			em.close();
			emTL.set(null);
		}
	}
	
	public static void main(String[] args) {
		// 我们已知jpa是通过hibernate实现所以应该可以通过EntityManager获取session
		Session session = getEM().unwrap(Session.class);
		session.doWork(new Work() {
			
			@Override
			public void execute(Connection conn) throws SQLException {
				System.out.println(conn);
				
			}
		});
	}
	

}

　增删改查核心Daoimpl层

 

package com.itheima.dao.impl;

import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Projections;

import com.itheima.dao.CusDAO;
import com.itheima.entity.Customer;
import com.itheima.util.HibernateUtils;

public class CusDAOImpl implements CusDAO {

    // 获取session
    private Session session = HibernateUtils.getSession();
    
    @Override
    public boolean saveCus(Customer cus) throws RuntimeException {
        // 设定返回值
        boolean con = false;
        Transaction tx = null;
        try {
            // 开启事务
            tx = session.beginTransaction();
            // 事务操作
            session.save(cus);
            // 提交
            tx.commit();
            // 改变方法返回值
            con = true;
        } catch (Exception e) {
            tx.rollback();
            System.out.println("操作报错!" + e.getMessage());
            e.printStackTrace();
        }
        // 返回
        return con;
    }

    @Override
    public boolean updateCus(Customer cus) throws RuntimeException {
        // 设定返回值
        boolean con = false;
        Transaction tx = null;
        try {
            // 开启事务
            tx = session.beginTransaction();
            // 事务操作
            session.update(cus);
            // 提交
            tx.commit();
            // 改变方法返回值
            con = true;
        } catch (Exception e) {
            tx.rollback();
            System.out.println("操作报错!" + e.getMessage());
            e.printStackTrace();
        }
        // 返回
        return con;
    }

    @Override
    public boolean deleteCus(Customer cus) throws RuntimeException {
        // 设定返回值
        boolean con = false;
        Transaction tx = null;
        try {
            // 开启事务
            tx = session.beginTransaction();
            // 事务操作
            session.delete(cus);
            // 提交
            tx.commit();
            // 改变方法返回值
            con = true;
        } catch (Exception e) {
            tx.rollback();
            System.out.println("操作报错!" + e.getMessage());
            e.printStackTrace();
        }
        // 返回
        return con;
    }

    @Override
    public Customer findCusByID(Long id) throws RuntimeException {
        // 创建方法的返回值
        Customer cus = null;
        // 按ID查询
        cus = session.get(Customer.class, id);
        // 返回
        return cus;
    }

    @Override
    public List<Customer> findCusListByPage(Integer pageIndex, Integer pageSize) throws RuntimeException {
        // 创建方法的返回值
        List<Customer> list = null;
        // 创建查询对象
        Criteria criteria = session.createCriteria(Customer.class);
        // 分页
        criteria.setFirstResult((pageIndex-1)*pageSize);
        criteria.setMaxResults(pageSize);
        // 获取数据
        list = criteria.list();
        // 返回
        return list;
    }

    @Override
    public int findCusListByPageCount() throws RuntimeException {
        // 设定方法的返回值
        int totalCount = 0;
        // 创建查询参数
        Criteria criteria = session.createCriteria(Customer.class);
        // 聚合函数
        criteria.setProjection(Projections.count("cid"));
        // 获取结果
        Number num = (Number)criteria.uniqueResult();
        totalCount = num.intValue();
        // 返回
        return totalCount;
    }

}