Hibernate—（关系）

最新推荐文章于 2024-05-15 16:24:09 发布
最新推荐文章于 2024-05-15 16:24:09 发布
阅读量262 收藏
点赞数
分类专栏： 框架 文章标签： hibernate hibernate关系 一对一 一对多 多对多
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a985548426/article/details/77507570
版权

一、一对一（举个例子 用户和身份证的关系）

         

 实体类：

①用户 

 User.java


package com.sun.entity;

public class User {
	private int uid;
	private String uname;
	private Card card;
	
	public Card getCard() {
		return card;
	}
	public void setCard(Card card) {
		this.card = card;
	}
	public User() {
		super();
		// TODO Auto-generated constructor stub
	}
	public User(String uname) {
		super();
		this.uname = uname;
	}
	public int getUid() {
		return uid;
	}
	public void setUid(int uid) {
		this.uid = uid;
	}
	public String getUname() {
		return uname;
	}
	public void setUname(String uname) {
		this.uname = uname;
	}
}
User.hbm.xml 

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2017-8-22 14:32:20 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
    <class name="com.sun.entity.User" table="USER">
        <id name="uid" type="int">
            <column name="UID" />  <!--主键-->
            <generator class="native" />
        </id>
        <property name="uname" type="java.lang.String">
            <column name="UNAME" />
        </property>
        <one-to-one name="card" class="com.sun.entity.Card" cascade="all-delete-orphan"></one-to-one> 
        <!--一对一-->
 </class></hibernate-mapping>











②身份证 


 Card.java




package com.sun.entity;

public class Card {
	private int uid;
	private String cnum;
	private User user;
	
	public User getUser() {
		return user;
	}
	public void setUser(User user) {
		this.user = user;
	}
	public Card() {
		super();
	}
	public Card(String cnum) {
		super();
		this.cnum = cnum;
	}
	public int getUid() {
		return uid;
	}
	public void setUid(int uid) {
		this.uid = uid;
	}
	public String getCnum() {
		return cnum;
	}
	public void setCnum(String cnum) {
		this.cnum = cnum;
	}
}

Card.hbm.xml





<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2017-8-22 14:32:20 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
    <class name="com.sun.entity.Card" table="CARD">
        <id name="uid" type="int">
            <column name="UID" />
            <generator class="foreign"> <!--外键-->
            	<param name="property">user</param>
            </generator>
        </id>
        <property name="cnum" type="java.lang.String">
            <column name="CNUM" />
        </property>
        <one-to-one name="user" class="com.sun.entity.User"></one-to-one> 
        <!--一对一-->
 </class>

</hibernate-mapping>






测试：





package com.sun.test;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.sun.entity.Card;
import com.sun.entity.User;

public class TestOneToOne {
	private SessionFactory sessionFactory;
	private Session session;
	private Transaction transaction;

	@Before
	public void before(){
		Configuration configuration=new Configuration().configure();
		sessionFactory = configuration.buildSessionFactory();
		session = sessionFactory.openSession();
		transaction = session.beginTransaction();
	}
	@After
	public void after(){
		transaction.commit();
		session.close();
		sessionFactory.close();
	}
	
	 //增加
	public void testAdd(){
		User user=new User("张三");
		Card card=new Card("43110731");
		
		//互设
		user.setCard(card);
		card.setUser(user);
		
		session.save(user);
		session.save(card);
	}
	 //根据id查询
	public void testGet(){
		User user=session.get(User.class, 1);
		System.out.println(user.getCard().getCnum());
	}
	//删除
	public void testDelete(){
		//删除主表
//		User user=session.get(User.class, 2);
//		session.delete(user);
		
		//删除从表
		Card card=session.get(Card.class, 3);
		card.getUser().setCard(null);
		session.delete(card);
		
	}
	
	
	
}








二、一对多（举个例子 省和市）












实体类：


①Province.java




package com.sun.entity;

import java.util.HashSet;
import java.util.Set;

public class Province {
	private int pid;
	private String pname;
	
	private Set<City> cities=new HashSet<City>();
	
	public Set<City> getCities() {
		return cities;
	}
	public void setCities(Set<City> cities) {
		this.cities = cities;
	}
	public Province() {
		super();
	}
	public Province(String pname) {
		super();
		this.pname = pname;
	}
	public int getPid() {
		return pid;
	}
	public void setPid(int pid) {
		this.pid = pid;
	}
	public String getPname() {
		return pname;
	}
	public void setPname(String pname) {
		this.pname = pname;
	}
}






Province.hbm.xml











<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2017-8-22 15:14:11 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
    <class name="com.sun.entity.Province" table="PROVINCE">
        <id name="pid" type="int">
            <column name="PID" />
            <generator class="native" />
        </id>
        <property name="pname" type="java.lang.String">
            <column name="PNAME" />
        </property>
        
        <set name="cities" table="city" cascade="save-update"> <!--cascde级联-->
        	<key column="pid"></key>
        	<one-to-many class="com.sun.entity.City"/>
        </set>
        
        
    </class>
</hibernate-mapping>




②City.java









package com.sun.entity;

public class City {
	private int cid;
	private String cname;
	
	private Province province;
	
	public Province getProvince() {
		return province;
	}
	public void setProvince(Province province) {
		this.province = province;
	}
	public City() {
		super();
		// TODO Auto-generated constructor stub
	}
	public City(String cname) {
		super();
		this.cname = cname;
	}
	public int getCid() {
		return cid;
	}
	public void setCid(int cid) {
		this.cid = cid;
	}
	public String getCname() {
		return cname;
	}
	public void setCname(String cname) {
		this.cname = cname;
	}

}








City.hbm.xml






<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2017-8-22 15:14:11 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
    <class name="com.sun.entity.City" table="CITY">
        <id name="cid" type="int">
            <column name="CID" />
            <generator class="native" />
        </id>
        <property name="cname" type="java.lang.String">
            <column name="CNAME" />
        </property>
       <!--  <property name="pid" type="int">
            <column name="PID" />
        </property> -->
        <many-to-one name="province" class="com.sun.entity.Province" column="pid"></many-to-one>
    </class>
</hibernate-mapping>




测试： 











package com.sun.test;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.sun.entity.Card;
import com.sun.entity.City;
import com.sun.entity.Province;
import com.sun.entity.User;

public class TestOneToMany {
	private SessionFactory sessionFactory;
	private Session session;
	private Transaction transaction;
	@Before
	public void before(){
		Configuration configuration=new Configuration().configure();
		sessionFactory = configuration.buildSessionFactory();
		session = sessionFactory.openSession();
		transaction = session.beginTransaction();
	}
	@After
	public void after(){
		transaction.commit();
		session.close();
		sessionFactory.close();
	}@Test
	public void testAdd(){   //增加（级联）
		Province province=new Province("湖南省");
		
		City city1=new City("长沙市");
		City city2=new City("娄底市");
		City city3=new City("其他市");
		
		province.getCities().add(city1);
		province.getCities().add(city2);
		province.getCities().add(city3);
		
		city1.setProvince(province);
		city2.setProvince(province);
		city3.setProvince(province);
		
		session.save(province);
	}
}








三、多对多（举个例子 用户和角色）


                    


实体类：


①Users.java









package com.sun.entity;

import java.util.HashSet;
import java.util.Set;

public class Users {
	private int uid;
	private String uname;
	
	private Set<Roles> roles=new HashSet<Roles>();
	
	public Set<Roles> getRoles() {
		return roles;
	}
	public void setRoles(Set<Roles> roles) {
		this.roles = roles;
	}
	public Users() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Users(String uname) {
		super();
		this.uname = uname;
	}
	public int getUid() {
		return uid;
	}
	public void setUid(int uid) {
		this.uid = uid;
	}
	public String getUname() {
		return uname;
	}
	public void setUname(String uname) {
		this.uname = uname;
	}
	
}




Users.hbm.xml






<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2017-8-22 15:41:45 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
    <class name="com.sun.entity.Users" table="USERS">
        <id name="uid" type="int">
            <column name="UID" />
            <generator class="native" />
        </id>
        <property name="uname" type="java.lang.String">
            <column name="UNAME" />
        </property>
        
        <set name="roles" table="u_r" cascade="save-update">
        	<key column="uid"></key>
        	<many-to-many class="com.sun.entity.Roles" column="rid"></many-to-many>
        </set>
        
        
    </class>
</hibernate-mapping>






②Roles.java









package com.sun.entity;

import java.util.HashSet;
import java.util.Set;

public class Roles {
	private int rid;
	private String rname;
	
	private Set<Users> users=new HashSet<Users>();
	
	public Set<Users> getUsers() {
		return users;
	}
	public void setUsers(Set<Users> users) {
		this.users = users;
	}
	public Roles() {
		super();
	}
	public Roles(String rname) {
		super();
		this.rname = rname;
	}
	public int getRid() {
		return rid;
	}
	public void setRid(int rid) {
		this.rid = rid;
	}
	public String getRname() {
		return rname;
	}
	public void setRname(String rname) {
		this.rname = rname;
	}
}




Roles.hbm.xml











<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2017-8-22 15:41:45 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
    <class name="com.sun.entity.Roles" table="ROLES">
        <id name="rid" type="int">
            <column name="RID" />
            <generator class="native" />
        </id>
        <property name="rname" type="java.lang.String">
            <column name="RNAME" />
        </property>
        
        <set name="users" table="u_r">
        	<key column="rid"></key>
        	<many-to-many class="com.sun.entity.Users" column="uid"></many-to-many><!--多对多-->
        </set>
        
    </class>
</hibernate-mapping>





测试：









package com.sun.test;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.sun.entity.Card;
import com.sun.entity.City;
import com.sun.entity.Province;
import com.sun.entity.Roles;
import com.sun.entity.User;
import com.sun.entity.Users;

public class TestManyToMany {
	private SessionFactory sessionFactory;
	private Session session;
	private Transaction transaction;

	@Before
	public void before(){
		Configuration configuration=new Configuration().configure();
		sessionFactory = configuration.buildSessionFactory();
		session = sessionFactory.openSession();
		transaction = session.beginTransaction();
	}
	@After
	public void after(){
		transaction.commit();
		session.close();
		sessionFactory.close();
	}
	
	@Test
	public void testAdd(){
		Users users1=new Users("辉辉");
		Users users2=new Users("静静");
		
		Roles roles1=new Roles("老公");
		Roles roles2=new Roles("老婆");
		Roles roles3=new Roles("儿子");
		Roles roles4=new Roles("孙子");
		
		users1.getRoles().add(roles1);
		users1.getRoles().add(roles3);
		users1.getRoles().add(roles4);
		users2.getRoles().add(roles2);
		users2.getRoles().add(roles4);
		
		
		session.save(users1);
		session.save(users2);
		
	}
}















公共的pop.xml









<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>hibernate02</groupId>
  <artifactId>hibernate02</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>hibernate02 Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <properties>  
      <argLine>-Dfile.encoding=UTF-8</argLine>
  </properties>
  
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
    
    <dependency>
	    <groupId>javax.servlet</groupId>
	    <artifactId>javax.servlet-api</artifactId>
	    <version>4.0.0-b07</version>
	    <scope>provided</scope>
	</dependency>
    
    
    <!-- 加入hibernate依赖 -->
    <dependency>
	   <groupId>org.hibernate</groupId>
	   <artifactId>hibernate-core</artifactId>
	   <version>5.2.10.Final</version>
	</dependency>
    
    <!-- Mysql依赖 -->
    <dependency>
    	<groupId>mysql</groupId>
    	<artifactId>mysql-connector-java</artifactId>
    	<version>5.1.43</version>
    </dependency>
    
  </dependencies>
  <build>
    <finalName>hibernate02</finalName>
  </build>
</project>






公共的hibernate.cfg.xml




<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC

		"-//Hibernate/Hibernate Configuration DTD 3.0//EN"

		"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

    <session-factory>

        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>

        <property name="hibernate.connection.password">password</property>

        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/test</property>

        <property name="hibernate.connection.username">root</property>
        
        <property name="show_sql">true</property>
        <property name="format_sql">true</property>
        
        <mapping resource="com/sun/entity/User.hbm.xml"/>
        <mapping resource="com/sun/entity/Card.hbm.xml"/>
        <mapping resource="com/sun/entity/Province.hbm.xml"/>
        <mapping resource="com/sun/entity/City.hbm.xml"/>
        
        <mapping resource="com/sun/entity/Users.hbm.xml"/>
        <mapping resource="com/sun/entity/Roles.hbm.xml"/>
    </session-factory>

</hibernate-configuration>




























                

        

        

    




    

      

        

            

              
                
                  橙汁丶
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
hibernate关联关系

				
			

			

				

					weixin_56069070的博客
				

				

					10-25
					
					6507
					
				

			

		

		

			
				
前言：今天要分享的知识是hibernate框架的关联关系

码字不易，点个赞

转载请说明！

开发工具:eclipse

目录

一、一对多的配置

二、懒加载

1、定义：懒加载可以这样理解，只加载某一项东西，其他的东西不会加载

2、操作：在我们进行项目的操作时候，就会想到，当自己把订单的id查出来之后，改订单id下面的对应的订单项会不会也同样出来

三、一对多的自关联

1、定义：一对多的自关联就好比做树形菜单的时候，就会出现一个最大的节点，下面会有很多的子节点。

2、案例

四、多对多的配置
.

			
		

	



                

              
                



	

		

			

				
					
Hibernate：one-to-one（一对一）关联映射详解

				
			

			

				

					SirouW的博客
				

				

					09-03
					
					2650
					
				

			

		

		

			
				
对one-to-one关联映射进行详细的叙述

			
		

	



                


  
              

                


	

		

			

				
					
浅谈JPA二：JPA与Hibernate关系

				
			

			

				

					localhost01
				

				

					10-27
					
					1301
					
				

			

		

		

			
				
JPA &amp;amp;amp;amp;amp;amp; Hibernate 关系
JPA是需要Provider来实现其功能的，Hibernate就是JPA Provider中很强的一个。
从功能上来说，JPA现在就是Hibernate功能的一个子集。可以简单的理解为JPA是标准接口，Hibernate是实现及扩展。
Hibernate主要是通过三个组件来实现：hibernate-annotation、hibernate-entity......

			
		

	





	

		

			

				
					
Hibernate关系映射基础

				
			

			

				

					morris
				

				

					11-12
					
					9124
					
				

			

		

		

			
				
1.  Hibernate关系映射基础
1.1.  Doctype





"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">




指定根元素和dtd文件的命名空间。
1.2.  hibernate-mapping





         schema="schemaName"


			
		

	



		

			
		



	

		

			

				
					
JPA和Hibernate关系之浅谈

				
			

			

				

					陌上曦夏的博客
				

				

					04-27
					
					1495
					
				

			

		

		

			
				
首先我们来看一下百度百科关于JPA的解释，JPA全称Java Persistence API。JPA通过JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。JPA的总体思想和现有Hibernate、TopLink、JDO等ORM框架大体一致。总的来说，JPA包括以下3方面的技术：ORM映射元数据，API，查询语言。由此可知，Jpa是一种规范，而Hiberna

			
		

	





	

		

			

				
					
Spring Data JPA和Hibernate 之间的关系

				
			

			

				

					m0_49514150的博客
				

				

					03-14
					
					3430
					
				

			

		

		

			
				
JPA
JPA 是 Java Persistence API 的简称，中文名 Java 持久层 API，是 JDK 5.0 注解或 XML 描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。
Sun 引入新的 JPA ORM 规范出于两个原因：其一，简化现有 Java EE 和 Java SE 应用开发工作；其二，Sun 希望整合 ORM 技术，实现天下归一。
JPA 由 EJB 3.0 软件专家组开发，作为 JSR-220 实现的一部分。但它又不限于 EJB 3.0，你可以在 Web 应用

			
		

	





	

		

			

				
					
Hibernate基本使用

				
			

			

				

					qq_45429856的博客
				

				

					04-13
					
					5531
					
				

			

		

		

			
				

			
		

	





	

		

			

				
					
SpringBoot整合Hibernate

					
热门推荐

				
			

			

				

					忆晨的博客
				

				

					03-22
					
					1万+
					
				

			

		

		

			
				
Hibernate是什么？
Hibernate与MyBatis都是流行的持久层开发框架，只不过Hibernate是全自动ORM框架，不需要关心sql编写。
Hibernate 是一个高性能的对象/关系映射（ORM）持久化存储和查询的服务，不仅负责从Java类到数据库表的映射 （还包括从Java数据类型到SQL数据类型的映射），还提供了面向对象的数据查询检索机制，从而极大地缩短了手动处理SQL和JDBC上的开发时间。 同时，Hibernate还实现了JPA规范，在SpringBoot中，JPA的默认实现就是使

			
		

	





	

		

			

				
					
hibernate整合openGauss

				
			

			

				

					走在bug的路上
				

				

					09-26
					
					1961
					
				

			

		

		

			
				
hibernate整合openGauss

			
		

	





	

		

			

				
					
Hibernate学习笔记

				
			

			

				

					weixin_44653248的博客
				

				

					04-12
					
					1754
					
				

			

		

		

			
				
Hibernate学习笔记
一、简介
1.hibernate应用在dao层框架，在dao里对数据库crud操作，使用hibernate实现操作，hibernate底层代码就是jdbc，hibernate将jdbc进行了封装，不需要写sql语句实现，减少编写复杂代码。hibernate是开源轻量级框架。
2.orm思想：
①.hibernate使用orm思想对数据库进进行clud操作。
②orm：o...

			
		

	





	

		

			

				
					
hibernate 关系注解

				
			

			

				

					03-04
				

			

		

		

			
				
hibernate 关系注解：Hibernate Annotation关系映射

			
		

	





	

		

			

				
					
Hibernate关系映射

				
			

			

				

					06-12
				

			

		

		

			
				
熟悉Hibernate的“多对一”关系映射，并应用于web系统中

			
		

	





	

		

			

				
					
hibernate关系映射网址

				
			

			

				

					06-27
				

			

		

		

			
				
hibernate

			
		

	





	

		

			

				
					
hibernate关系映射

				
			

			

				

					05-29
				

			

		

		

			
				
hibernate关系映射，总结的关系映射，很全面，基本上涵盖所需要的全部映射关系

			
		

	





	

		

			

				
					
web安全学习笔记（15）

				
			

			

				

					m0_58875569的博客
				

				

					05-15
					
					651
					
				

			

		

		

			
				
记一下第25-26课的内容。弱口令爆破的四种模式与判断成功失败的三种方案；爆破中的验证码拦截+错误次数+IP限制+密码加密绕过 + IP获取的原理以及绕过CDN获取客户真实IP

			
		

	





	

		

			

				
					
基于TC72（SPI接口）温度传感器、STM32F103C8T6、LCD1602、FREERTOS的温度采集proteus仿真

				
			

			

				

					05-21
				

			

		

		

			
				
spi

			
		

	





	

		

			

				
					
ehcache-core-2.6.9.jar

				
			

			

				

					05-21
				

			

		

		

			
				
javaee/javaweb常用jar包，亲测可用，导入到java工程中即可使用

			
		

	





	

		

			

				
					
netty-transport-native-unix-common-4.1.51.Final.jar

				
			

			

				

					05-21
				

			

		

		

			
				
 javaEE  javaweb常用jar包 ， 亲测可用，下载后导入到java工程中使用。

			
		

	





	

		

			

				
					
node-v6.14.4-headers.tar.xz

					
最新发布

				
			

			

				

					05-21
				

			

		

		

			
				
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。

Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。

Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。

在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。



			
		

	





	

		

			

				
					
hibernate与jpa 的关系

				
			

			

				

					05-03
				

			

		

		

			
				
Hibernate是一个流行的ORM（对象关系映射）框架，它能够将Java对象映射到关系型数据库表中。Hibernate可以使用各种数据库，包括MySQL、PostgreSQL、Oracle等。它提供了丰富的ORM功能，如缓存、查询和事务管理等。  ...

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值