jpa/springdata(1)jpa

<persistence-unit name="jpa" transaction-type="RESOURCE_LOCAL">
		<!--  
		实际上配置的是  javax.persistence.spi.PersistenceProvider 接口的实现类， 若 JPA 项目中只有一个 JPA 的实现产品, 则也可以不配置该节点. 
		-->
		<provider>org.hibernate.ejb.HibernatePersistence</provider>
	
		<!-- 添加持久化类，类似hibernate的mapper或者config.addclass（）方法 -->
		<class>com.jpa.helloworld.Item</class>	
		<!-- 
		配置二级缓存的策略 
		ALL：所有的实体类都被缓存
		NONE：所有的实体类都不被缓存. 
		ENABLE_SELECTIVE：标识 @Cacheable(true) 注解的实体类将被缓存
		DISABLE_SELECTIVE：缓存除标识 @Cacheable(false) 以外的所有实体类
		UNSPECIFIED：默认值，JPA 产品默认值将被使用
		-->
		<shared-cache-mode>ENABLE_SELECTIVE</shared-cache-mode>
	
		<properties>
			<!-- 连接数据库的基本信息 -->
			<property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
			<property name="javax.persistence.jdbc.url" value="jdbc:mysql:///jpa"/>
			<property name="javax.persistence.jdbc.user" value="root"/>
			<property name="javax.persistence.jdbc.password" value="1230"/>
			
			<!-- 配置 JPA 实现产品的基本属性. 配置 hibernate 的基本属性，同hibernate的配置 -->
			<property name="hibernate.format_sql" value="true"/>
			<property name="hibernate.show_sql" value="true"/>
			<property name="hibernate.hbm2ddl.auto" value="update"/>
			
			<!-- 同hibernate二级缓存配置 -->
			<property name="hibernate.cache.use_second_level_cache" value="true"/>
			<property name="hibernate.cache.region.factory_class" value="org.hibernate.cache.ehcache.EhCacheRegionFactory"/>
			<property name="hibernate.cache.use_query_cache" value="true"/>
		</properties>
	</persistence-unit>

public static void main(String[] args) {
		
		String persistenceUnitName = "jpa";//与c3p0的配置类似的加载方法
		
		Map<String, Object> properites = new HashMap<String, Object>();
		properites.put("hibernate.show_sql", true);
		
		EntityManagerFactory entityManagerFactory = 
　　　　　　　　　　　　　　//在配置文件中配置好了直接获取
　　　　　　　　　　　　　　//Persistence.createEntityManagerFactory(persistenceUnitName);
　　　　　　　　　　//在put中放置需要设置的属性，假如在xml中已经配置，那么将覆盖xml中的属性
　　　　　　　　　　Persistence.createEntityManagerFactory(persistenceUnitName, properites);				
　　　　　　　　　　EntityManager entityManager = entityManagerFactory.createEntityManager();
　　　　　　　　　　EntityTransaction transaction = entityManager.getTransaction();
　　　　　　　　　　transaction.begin();//开始事务
　　　　　　　　　　transaction.commit();//提交事物	
　　　　　　　　　　entityManager.close();
　　　　　　　　　　entityManagerFactory.close();
	}                    

@Table(name="JPA_ORDERS")//对应的表名
@Entity//标注为实体类
public class Dept {
　　　　private Integer id;
　　　　private String deptName;

　　　　@GeneratedValue/*获取主键的方式，主键id的描述，在hibernate中，以及mybatis中的resultmap的都是描述为id标签，
这里获取主键的方式有IDENTITY：采用数据库 ID自增长的方式来自增主键段，Oracle 不支持这种方式；AUTO： JPA自动选择合适的策略，
是默认选项（因为是默认的选项所以也可以不写）；SEQUENCE：通过序列产生主键，通过 @SequenceGenerator 注解指定序列名，MySql 
不支持这种方式，TABLE：通过表产生主键，框架借由表模拟序列产生主键，使用该策略可以使应用更易于数据库移植。@GeneratedValue(strategy=GenerationType.AUTO)，
GenerationType.TABLE有些特殊但是避免了数据库切换不兼容的问题
　　　　@TableGenerator(name="ID_GENERATOR",   //与generator="ID_GENERATOR"的值一致
　　　　table="jpa_id_generators", //数据库表的名称，这里是三列，id，PK_NAME，PK_VALUE
　　　　pkColumnName="PK_NAME",//数据库表的对应的列的名称
　　　　pkColumnValue="CUSTOMER_ID",//向对应列的名称的值
　　　　valueColumnName="PK_VALUE",//数据库表的对应的列的名称
　　　　allocationSize=100)//这里设置的值，PK_VALUE设置为100，每次id自增100
　　　　@GeneratedValue(strategy=GenerationType.TABLE,generator="ID_GENERATOR")
   
*/
	@Id
	public Integer getId() {
		return id;
	}
       
	public void setId(Integer id) {
		this.id = id;
	}

	@Column(name="DEPT_NAME")/*对应数据库的名称，也是新建数据库的名称，假如数据库的名称与属性的名称一致，那么这类的注解也可以默认不写，
　　在所有的默认的get方法上会默认的添加@Basic注解，假如在没有set方法的前提下会报错，假如现在有一个get方法，但是不需要与数据库相关联，
　　那么在get方法上使用@Transient，jap处理注解在类方法上的注解，其余都在get方法上，Column还具有以下一些属性 ，unique（唯一）  、
　　nullable（不能为null） 、length （长度）等， @Column(name="LAST_NAME",length=50,nullable=false)*/
	public String getDeptName() {
		return deptName;
	} 

	public void setDeptName(String deptName) {
		this.deptName = deptName;
	}

        @Transient
         public  void getInfo() {
		System.out.println(111);
	}                
}                

@Temporal(TemporalType.DATE)//可选TemporalType.TIME，TemporalType.DATE，TemporalType.TIMESTAMP
public java.util.Date getDate() {
	return date;
} 

customer.setId(4);
Customer customer2 = entityManager.find(Customer.class, 4);
entityManager.merge(customer);
System.out.println(customer == customer2); //false

    @JoinColumn(name="MGR_ID", unique=true)//对应列，unique=true满足唯一
    @OneToOne(fetch=FetchType.LAZY)//fetch=FetchType.LAZY延迟加载，存在的异常类似hibernate的load
    public Manager getMgr() {
        return mgr;
    }//单向一对一

    @OneToOne(mappedBy="mgr")//mappedBy="mgr"表示维护的一端，没写默认都是对应主键的外键关联
    public Department getDept() {
        return dept;
    }//双向一对一

  @JoinColumn(name="CUSTOMER_ID")
    @OneToMany(fetch=FetchType.LAZY,cascade={CascadeType.REMOVE},mappedBy="customer")//cascade={CascadeType.REMOVE}级联，mappedBy="customer"维护的一端
    public Set<Order> getOrders() {
        return orders;
 }

@JoinColumn(name="CUSTOMER_ID")
    @ManyToOne(fetch=FetchType.LAZY)
    public Customer getCustomer() {
        return customer;
    }

@ManyToMany(mappedBy="categories")
    public Set<Item> getItems() {
        return items;
   }

@JoinTable(name="ITEM_CATEGORY",      //@JoinTable 来映射中间表，name 指向中间表的名字，多对多是基于外表的
            joinColumns={@JoinColumn(name="ITEM_ID", referencedColumnName="ID")},//joinColumns 映射当前类所在的表在中间表中的外键，name 指定外键列的列名，

referencedColumnName 指定外键列关联当前表的哪一列，inverseJoinColumns={@JoinColumn(name="CATEGORY_ID", referencedColumnName="ID")})//inverseJoinColumns

映射关联的类所在中间表的外键 
    @ManyToMany
    public Set<Category> getCategories() {
        return categories;
    }

public void testPartlyProperties(){
        String jpql = "SELECT new Customer(c.lastName, c.age) FROM Customer c WHERE c.id > ?";/*Customer c，根据Customer的注释可以找到表名，new Customer(c.lastName, c.age)，
根据查询结果进行填充*/
        List result = entityManager.createQuery(jpql).setParameter(1, 1).getResultList();
        System.out.println(result);
 }

<?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:context="http://www.springframework.org/schema/context"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">

	<!-- 配置自动扫描的包 -->
	<context:component-scan base-package="com.jpa"></context:component-scan>

	<context:property-placeholder location="classpath:db.properties"/>

	<bean id="dataSource"
		class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="user" value="${jdbc.user}"></property>
		<property name="password" value="${jdbc.password}"></property>
		<property name="driverClass" value="${jdbc.driverClass}"></property>
		<property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>		
		<!-- 配置其他属性 -->
	</bean>
	
	<!-- 配置 EntityManagerFactory -->
	<bean id="entityManagerFactory"
		class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
		<!-- 配置数据源 -->
　　　　　　　　　 <property name="dataSource" ref="dataSource"></property>
		<!-- 配置 JPA 提供商的适配器. 可以通过内部 bean 的方式来配置 -->
		<property name="jpaVendorAdapter">
			<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"></bean>
		</property>	
		<!-- 扫描指定包下的@entitiy -->
		<property name="packagesToScan" value="com.jpa.spring.entities"></property>
		<!-- 配置 JPA 的基本属性. 例如 JPA 实现产品的属性（根据提供商的适配器） -->
		<property name="jpaProperties">
			<props>
				<prop key="hibernate.show_sql">true</prop>
				<prop key="hibernate.format_sql">true</prop>
				<prop key="hibernate.hbm2ddl.auto">update</prop>
			</props>
		</property>
	</bean>
	
	<!-- 配置 JPA 使用的事务管理器 -->
	<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
		<property name="entityManagerFactory" ref="entityManagerFactory"></property>	
	</bean>
	
	<!-- 配置支持基于注解是事务配置 -->
	<tx:annotation-driven transaction-manager="transactionManager"/>

</beans>

public class Test {
	private  static ApplicationContext  ctx=null;
	{
		ctx= new ClassPathXmlApplicationContext("application.xml");
	}
	
	@org.junit.Test
	public  void   testC3p0(){
		ComboPooledDataSource bean = ctx.getBean(ComboPooledDataSource.class);
		System.out.println(bean);
	}
	
	@org.junit.Test
	public  void testEntity() throws SQLException{
		LocalContainerEntityManagerFactoryBean lcemf = ctx.getBean(LocalContainerEntityManagerFactoryBean.class);
		DataSource dataSource = lcemf.getDataSource();
		Connection connection = dataSource.getConnection();
		System.out.println(connection);
	}
}
@org.junit.Test
	public  void testEntity() throws SQLException{
		LocalContainerEntityManagerFactoryBean lcemf = ctx.getBean(LocalContainerEntityManagerFactoryBean.class);
//		DataSource dataSource = lcemf.getDataSource();
//		Class<? extends EntityManager> entityManagerInterface = lcemf.getEntityManagerInterface();
		EntityManagerFactory en = lcemf.getNativeEntityManagerFactory();
		EntityManager manager = en.createEntityManager();
		EntityTransaction transaction = manager.getTransaction();
		transaction.begin();
			Person person = new  Person();
			person.setBrith(new Date());
			person.setEamil("11@11");
			person.setLastName("john");
			manager.persist(person);
		transaction.commit();
		manager.close();
		en.close();
//		if(lcemf  instanceof  EntityManager){//false
//			System.out.println(true);
//		}
//		Connection connection = dataSource.getConnection();
//		System.out.println(connection);		
	}

@Repository
public class PersonDao {

	@PersistenceContext//上述测试类的一系列代码，应为LocalContainerEntityManagerFactoryBean不是EntityManager
	private EntityManager entityManager;
	
	public void save(Person person){
		entityManager.persist(person);
	}
	
}