hibernate入门使用系列 说明篇+快速构建篇

最新推荐文章于 2024-09-30 16:29:12 发布
最新推荐文章于 2024-09-30 16:29:12 发布
阅读量108 收藏
点赞数
分类专栏： hibernate 文章标签： Hibernate junit Myeclipse MySQL SQL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/walsh_bupt/article/details/83283391
版权
转载：http://www.iteye.com/topic/189635
说明篇


写这个 入门使用 系列的文章，算是一个简单的复习吧。

目的1是让没有用过hibernate的工作者们，快速的使用起来。不会介绍太多的深层次的东西。仅仅是一个入门使用而已。


目的2是总结一下hibernate的基本使用，顺便自己再熟悉熟悉。


目的3是交流心得。一个人掌握的东西只有一点点。且掌握的程度有深有浅，如不交流、固步自封，只有被淘汰。欢迎任何人拍砖的。群众的力量是无穷的。在此系列中，难免会有些不恰当或者不对的地方。尽请指出、批评。

对于认为已经熟练掌握hibernate的高手们，可能没有什么用处。但是，无限欢迎交流。

废话不多说，下面开始进入主题。

快速构建篇

一. 何谓hibernate？
答：you can find the answer @google ...

二. 快速构建。
在此先要说明一下。由于本人懒惰，记不住hibernate的配置选项，所以，此系列的实例都是使用myeclipse进行快速开发。各位对myeclipse不齿的，就请见谅。然后，数据库都是mysql。

下面开始利用hibernate进行数据库的访问。

需求：实现对用户的增、删、改、查。为了方便，用户就2个属性 用户ID和用户名。实体模型如下：



建立工程:HibernateQuickUse，并且建立包。如下：





根据实体，创建类User，代码如下：

Java代码 
package org.py.hib.quickstart;   

/**  
 * User entity.  
 * @author MyEclipse Persistence Tools  
 */  

@SuppressWarnings("serial")   
public class User implements java.io.Serializable   
{   
    private String id;   
    private String name;   

    public User()   
    {   
    }   

    public String getId()   
    {   
        return this.id;   
    }   

    public void setId(String id)   
    {   
        this.id = id;   
    }   

    public String getName()   
    {   
        return this.name;   
    }   

    public void setName(String name)   
    {   
        this.name = name;   
    }   
}  

package org.py.hib.quickstart;

/**
 * User entity.
 * @author MyEclipse Persistence Tools
 */

@SuppressWarnings("serial")
public class User implements java.io.Serializable
{
	private String id;
	private String name;

	public User()
	{
	}

	public String getId()
	{
		return this.id;
	}

	public void setId(String id)
	{
		this.id = id;
	}

	public String getName()
	{
		return this.name;
	}

	public void setName(String name)
	{
		this.name = name;
	}
}


根据实体，创建数据表。sql如下：

Sql代码 
use HibernateQuickUse;   
drop table if exists User;   

create table user (   
    id varchar(32) primary key,   
    name varchar(32)   
);  

use HibernateQuickUse;
drop table if exists User;

create table user (
	id varchar(32) primary key,
	name varchar(32)
);

这里的id，我没有采用Integer auto_increment, 原因是为了数据库的数据能方便的导入到另外一种数据库里面，比方说：oracle。当然，这个是以牺牲部分效率为前提的。因为id是integer的，能更加快速查询。不过，从数据库会自动为 primary key 建立 index来看，效率也不会相差太多。

要想通过hibernate访问数据库。首先要建立描述数据库的文件：hibernate.cfg.xml。放到src下面。内容如下：

Xml代码 
<?xml version='1.0' encoding='UTF-8'?>  
<!DOCTYPE hibernate-configuration PUBLIC   
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"   
          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">  

<hibernate-configuration>  

    <session-factory>  
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>  
        <property name="connection.url">jdbc:mysql://localhost:3306/hibernatequickUse</property>  
        <property name="connection.username">root</property>  
        <property name="connection.password">root</property>  
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>  

        <property name="show_sql">true</property>  
        <mapping resource="org/py/hib/quickstart/User.hbm.xml" />  


    </session-factory>  

</hibernate-configuration>  

<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

	<session-factory>
		<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
		<property name="connection.url">jdbc:mysql://localhost:3306/hibernatequickUse</property>
		<property name="connection.username">root</property>
		<property name="connection.password">root</property>
		<property name="connection.driver_class">com.mysql.jdbc.Driver</property>

		<property name="show_sql">true</property>
		<mapping resource="org/py/hib/quickstart/User.hbm.xml" />


	</session-factory>

</hibernate-configuration>

说说上面的 "dialect", 这个对应着hibernate生成哪种数据库的sql。

然后是："show_sql", 这个是为了调试时候输出sql语句到屏幕用的。

注意"mapping resource"部分。这个部分表示你的 实体- 数据库 映射文件的位置。（什么是实体-数据库 映射文件，看下面。）



实体-数据库映射文件 -- 主要是告诉hibernate，这个User类，对应着哪个table，User类里面的那个属性对应着table里面的哪个字段。

我们可以建立 实体-数据库 的xml映射文件，也可以采用Annotations映射，但是目前只说xml映射方式。如下：

Xml代码 
<?xml version="1.0" encoding="utf-8"?>  
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"   
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  

<hibernate-mapping>  
    <class name="org.py.hib.quickstart.User" table="user">  
                <id name="id" type="java.lang.String" column="id" length="32">  
            <generator class="uuid" />  
        </id>  

        <property name="name"  type="java.lang.String" column="name" length="32" />  
    </class>  
</hibernate-mapping>  

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
	<class name="org.py.hib.quickstart.User" table="user">
                <id name="id" type="java.lang.String" column="id" length="32">
			<generator class="uuid" />
		</id>

		<property name="name"  type="java.lang.String" column="name"	length="32" />
	</class>
</hibernate-mapping>


上面的xml还是很好理解的。注意一个generator中的class，他可以有很多。我们这用的是uuid。什么是uuid。这个可以google一下。呵呵。google是最好的教科书。还能有很多其他的，比方说：native。具体的同样请教google。

有了上面的准备，那么我们开始来测试一下。这里我们用junit。具体怎么使用junit，呵呵。答案我想大家都知道了，也不用我说了。其实我对test 和 使用它也不熟练。

我把测试用力放到了test/org.py.hib.quickstart下面。代码如下：

Java代码 
package org.py.hib.quickstart;   

import junit.framework.Assert;   
import junit.framework.TestCase;   

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;   

public class QuickStartTest extends TestCase   
{   
    SessionFactory factory;   

    String m_name = "ryanpoy";   

    String m_name2 = "ryanpoy2";   

    @Before  
    public void setUp() throws Exception   
    {   
        Configuration conf = new Configuration().configure();   
        factory = conf.buildSessionFactory();   
    }   

    /**  
     * 测试添加  
     * @throws Exception  
     */  
    public void testSave() throws Exception   
    {   
        System.out.println("\n=== test save ===");   
        User u = new User();   
        u.setName(m_name); // 设置用户名 = m_name   

        Session session = null;   
        Transaction tran = null;   
        try  
        {   
            session = factory.openSession();   
            tran = session.beginTransaction();   
            session.save(u);   
            tran.commit();   

            Assert.assertEquals(u.getId() != null, true);   
        } catch (Exception ex)   
        {   
            tran.rollback();   
            throw ex;   
        } finally  
        {   
            if (session != null)   
            {   
                try  
                {   
                    session.close();   
                } catch (Exception ex)   
                {   
                    // nothing to do   
                } finally  
                {   
                    if (session != null)   
                        session = null;   
                }   
            }   
        }   
    }   

    /**  
     * 测试查询  
     * @throws Exception  
     */  
    public void testFind() throws Exception   
    {   
        System.out.println("\n=== test find ===");   
        Session session = null;   
        try  
        {   
            session = factory.openSession();   
            User u = (User) session.createQuery("from User").list().get(0);   

            Assert.assertEquals(true, u.getId() != null);   
            Assert.assertEquals(m_name, u.getName());   
        } catch (Exception ex)   
        {   
            throw ex;   
        } finally  
        {   
            if (session != null)   
            {   
                try  
                {   
                    session.close();   
                } catch (Exception ex)   
                {   
                    // nothing to do   
                } finally  
                {   
                    if (session != null)   
                        session = null;   
                }   
            }   
        }   
    }   

    /**  
     * 测试修改  
     * @throws Exception  
     */  
    public void testModify() throws Exception   
    {   
        System.out.println("\n=== test modify ===");   
        Session session = null;   
        Transaction tran = null;   
        try  
        {   
            session = factory.openSession();   
            tran = session.beginTransaction();   

            User u = (User) session.createQuery("from User").list().get(0);   
            u.setName(m_name2);  // 修改用户名 = m_name2.（原来用户名= m_name）   
            tran.commit();   

        } catch (Exception ex)   
        {   
            throw ex;   
        } finally  
        {   
            if (session != null)   
            {   
                try  
                {   
                    session.close();   
                } catch (Exception ex)   
                {   
                    // nothing to do   
                } finally  
                {   
                    if (session != null)   
                        session = null;   
                }   
            }   
        }   

        /*  
         * 修改后再查询  
         */  
        System.out.println("\n=== test find after modify ===");   
        try  
        {   
            session = factory.openSession();   
            User u = (User) session.createQuery("from User").list().get(0);   

            Assert.assertEquals(true, u.getId() != null);   
            Assert.assertEquals(m_name2, u.getName());   
        } catch (Exception ex)   
        {   
            throw ex;   
        } finally  
        {   
            if (session != null)   
            {   
                try  
                {   
                    session.close();   
                } catch (Exception ex)   
                {   
                    // nothing to do   
                } finally  
                {   
                    if (session != null)   
                        session = null;   
                }   
            }   
        }   
    }   

    /**  
     * 测试删除  
     * @throws Exception  
     */  
    public void testDelete() throws Exception   
    {   
        System.out.println("\n=== test delete ===");   
        Session session = null;   
        Transaction tran = null;   
        try  
        {   
            session = factory.openSession();   
            tran = session.beginTransaction();   

            User u = (User) session.createQuery("from User").list().get(0);   
            session.delete(u);   
            tran.commit();   

        } catch (Exception ex)   
        {   
            throw ex;   
        } finally  
        {   
            if (session != null)   
            {   
                try  
                {   
                    session.close();   
                } catch (Exception ex)   
                {   
                    // nothing to do   
                } finally  
                {   
                    if (session != null)   
                        session = null;   
                }   
            }   
        }   

        /*  
         * 删除后再查询  
         */  
        System.out.println("\n=== test find after delete ===");   
        try  
        {   
            session = factory.openSession();   
            Integer num = (Integer) session.createQuery("from User").list().size();   

            Assert.assertEquals(0, num.intValue());   
        } catch (Exception ex)   
        {   
            throw ex;   
        } finally  
        {   
            if (session != null)   
            {   
                try  
                {   
                    session.close();   
                } catch (Exception ex)   
                {   
                    // nothing to do   
                } finally  
                {   
                    if (session != null)   
                        session = null;   
                }   
            }   
        }   
    }   

    /**  
     *   
     */  
    @After  
    public void tearDown() throws Exception   
    {   
        factory.close();   
    }   

}  

package org.py.hib.quickstart;

import junit.framework.Assert;
import junit.framework.TestCase;

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;

public class QuickStartTest extends TestCase
{
	SessionFactory factory;

	String m_name = "ryanpoy";

	String m_name2 = "ryanpoy2";

	@Before
	public void setUp() throws Exception
	{
		Configuration conf = new Configuration().configure();
		factory = conf.buildSessionFactory();
	}

	/**
	 * 测试添加
	 * @throws Exception
	 */
	public void testSave() throws Exception
	{
		System.out.println("\n=== test save ===");
		User u = new User();
		u.setName(m_name); // 设置用户名 = m_name

		Session session = null;
		Transaction tran = null;
		try
		{
			session = factory.openSession();
			tran = session.beginTransaction();
			session.save(u);
			tran.commit();

			Assert.assertEquals(u.getId() != null, true);
		} catch (Exception ex)
		{
			tran.rollback();
			throw ex;
		} finally
		{
			if (session != null)
			{
				try
				{
					session.close();
				} catch (Exception ex)
				{
					// nothing to do
				} finally
				{
					if (session != null)
						session = null;
				}
			}
		}
	}

	/**
	 * 测试查询
	 * @throws Exception
	 */
	public void testFind() throws Exception
	{
		System.out.println("\n=== test find ===");
		Session session = null;
		try
		{
			session = factory.openSession();
			User u = (User) session.createQuery("from User").list().get(0);

			Assert.assertEquals(true, u.getId() != null);
			Assert.assertEquals(m_name, u.getName());
		} catch (Exception ex)
		{
			throw ex;
		} finally
		{
			if (session != null)
			{
				try
				{
					session.close();
				} catch (Exception ex)
				{
					// nothing to do
				} finally
				{
					if (session != null)
						session = null;
				}
			}
		}
	}

	/**
	 * 测试修改
	 * @throws Exception
	 */
	public void testModify() throws Exception
	{
		System.out.println("\n=== test modify ===");
		Session session = null;
		Transaction tran = null;
		try
		{
			session = factory.openSession();
			tran = session.beginTransaction();

			User u = (User) session.createQuery("from User").list().get(0);
			u.setName(m_name2);  // 修改用户名 = m_name2.（原来用户名= m_name）
			tran.commit();

		} catch (Exception ex)
		{
			throw ex;
		} finally
		{
			if (session != null)
			{
				try
				{
					session.close();
				} catch (Exception ex)
				{
					// nothing to do
				} finally
				{
					if (session != null)
						session = null;
				}
			}
		}

		/*
		 * 修改后再查询
		 */
		System.out.println("\n=== test find after modify ===");
		try
		{
			session = factory.openSession();
			User u = (User) session.createQuery("from User").list().get(0);

			Assert.assertEquals(true, u.getId() != null);
			Assert.assertEquals(m_name2, u.getName());
		} catch (Exception ex)
		{
			throw ex;
		} finally
		{
			if (session != null)
			{
				try
				{
					session.close();
				} catch (Exception ex)
				{
					// nothing to do
				} finally
				{
					if (session != null)
						session = null;
				}
			}
		}
	}

	/**
	 * 测试删除
	 * @throws Exception
	 */
	public void testDelete() throws Exception
	{
		System.out.println("\n=== test delete ===");
		Session session = null;
		Transaction tran = null;
		try
		{
			session = factory.openSession();
			tran = session.beginTransaction();

			User u = (User) session.createQuery("from User").list().get(0);
			session.delete(u);
			tran.commit();

		} catch (Exception ex)
		{
			throw ex;
		} finally
		{
			if (session != null)
			{
				try
				{
					session.close();
				} catch (Exception ex)
				{
					// nothing to do
				} finally
				{
					if (session != null)
						session = null;
				}
			}
		}

		/*
		 * 删除后再查询
		 */
		System.out.println("\n=== test find after delete ===");
		try
		{
			session = factory.openSession();
			Integer num = (Integer) session.createQuery("from User").list().size();

			Assert.assertEquals(0, num.intValue());
		} catch (Exception ex)
		{
			throw ex;
		} finally
		{
			if (session != null)
			{
				try
				{
					session.close();
				} catch (Exception ex)
				{
					// nothing to do
				} finally
				{
					if (session != null)
						session = null;
				}
			}
		}
	}

	/**
	 * 
	 */
	@After
	public void tearDown() throws Exception
	{
		factory.close();
	}

}

运行后，我们很欣慰的看到一路绿灯，全部通过了。那么测试没有问题。呵呵(这里的测试可能还不完善。请大家指出。前面说过，我对测试这块也不熟)。

看控制台，会输出如下信息：

Sql代码 
=== test save ===   
Hibernate: insert into hibernatequickuse.user (name, id) values (?, ?)   

=== test find ===   
Hibernate: select user0_.id as id2_, user0_.name as name2_ from hibernatequickuse.user user0_   

=== test modify ===   
Hibernate: select user0_.id as id4_, user0_.name as name4_ from hibernatequickuse.user user0_   
Hibernate: update hibernatequickuse.user set name=? where id=?   

=== test find after modify ===   
Hibernate: select user0_.id as id4_, user0_.name as name4_ from hibernatequickuse.user user0_   

=== test delete ===   
Hibernate: select user0_.id as id6_, user0_.name as name6_ from hibernatequickuse.user user0_   
Hibernate: delete from hibernatequickuse.user where id=?   

=== test find after delete ===   
Hibernate: select user0_.id as id6_, user0_.name as name6_ from hibernatequickuse.user user0_  

=== test save ===
Hibernate: insert into hibernatequickuse.user (name, id) values (?, ?)

=== test find ===
Hibernate: select user0_.id as id2_, user0_.name as name2_ from hibernatequickuse.user user0_

=== test modify ===
Hibernate: select user0_.id as id4_, user0_.name as name4_ from hibernatequickuse.user user0_
Hibernate: update hibernatequickuse.user set name=? where id=?

=== test find after modify ===
Hibernate: select user0_.id as id4_, user0_.name as name4_ from hibernatequickuse.user user0_

=== test delete ===
Hibernate: select user0_.id as id6_, user0_.name as name6_ from hibernatequickuse.user user0_
Hibernate: delete from hibernatequickuse.user where id=?

=== test find after delete ===
Hibernate: select user0_.id as id6_, user0_.name as name6_ from hibernatequickuse.user user0_


这些，就是hibernte自动生成的。仔细看看，其实就是标准sql。呵呵。懂jdbc的都能看懂。

好了，第一部分就到这。附件中的zip包是原代码。

语言的组织，举例的细节似乎像记流水账，看来还是没有文学细胞啊。忘了上次是哪位了，他写的标题就像是看 《圣斗士星矢》一项，激情洋溢啊。
walsh_bupt
关注
专栏目录
Hibernate入门jar包
12-09
本压缩包提供的是Hibernate入门所需的jar包，包括了Hibernate的核心库以及与之配合使用的相关组件。让我们深入探讨一下这些jar包以及它们在Hibernate中的作用。 1. Hibernate核心库： - `hibernate-core.jar`：这...
hibernate入门学习笔记+源码
04-25
**hibernate入门学习笔记+源码** **一、Hibernate简介** Hibernate是一个开源的对象关系映射（ORM）框架，它简化了Java应用与数据库之间的交互。通过提供对象化的数据访问方式，Hibernate消除了传统JDBC代码中的...
如何使用Hibernate？
m0_37884977的博客
01-30 3208
## hibernate 初体验 ## 首先我们需要创建一个数据库，这里起名为test，然后在该数据库下创建一个表product_。（这里我们只以product_测试）2.接着新建一个Java Web工程。在src目录下创建com.sss.pojo包和com.sss.test包。3.然后在pojo包下创建Prodcut和Product.hbm.xml。如下所示： 4:在src目录下创建hiberna
Hibernate基本使用
qq_45429856的博客
04-13 5838
简单的Hibernate使用入门
u014341567的博客
06-17 4945
hibernate所需要的jardao层User.hbm.xml&lt;!DOCTYPE hibernate-mapping PUBLIC     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"&gt;   &lt;!-- 配置表与实体对...
Hibernate的基本用法
天啦的呜啦啦的博客
03-30 2457
Hibernate 的基本开发步骤1.编写配置文档hibernat.cfg.xml例如: <session-factory> <!--数据库用户名--> <property name="connection.username">root</property> <!--数据库登录密码--> <property name="connection.password">1
Hibernate使用
李章勇的博客
04-13 383
Hibernate使用 　　hibernate是一个ORM框架。 　　ORM的全拼是Object Relational Mapping，译为“对象关系映射”，是一种程序技术，用于实现面向对象编程语言里不同类型系统的数据之间的转换。从效果上来说，它其实是创建了一个可以在编程语言里使用的“虚拟对象数据库”。 　　使用较多的ORM框架有：　　 JPA-...
maven构建hibernate入门使用（1）
u012516914的专栏
12-31 2089
1：创建maven工程，引入hibernate需要的依赖 junit junit 3.8.1 test org.hibernate hibernate-core 3.6.5.Final org.slf4j slf4j-api 1.6.1 mysql mysql-connector-jav
Hibernate-入门 idea + maven构建
jiaozongbenn的专栏
06-08 1072
前言 这篇文章记录我在idea中如何使用maven创建hibernate项目。 看这篇文章，你需要知道 Maven是什么hibernate是什么如何创建环境变量 你会知道如何 使用Junit进行测试让idea自动创建数据库映射文件在idea中可视化数据库使用hibernate对数据库添加数据 步骤记录 1.在idea的创建项目界面，选择Maven，并且选择
Hibernate快速入门+简单示例
互联网老辛
08-23 2528
很多人说Hbiernate已经没人用了,市面上有太多可供选择的开源工具.诚然市面上有很多新技术,但是作为初学者,还是要踏踏实实从基础做起,而且Hbiernate有自己的应用场景.       上篇博文:http    我们介绍了Hibernate的基本概念、Hibernate的核心以及Hibernate的执行原理，可以很好帮助我们从宏观上了解Hibernate， 再看这篇博客之前，请先回顾上篇
Hibernate(5.2.10)快速入门第一篇
qq_33513600的博客
05-08 694
 一、初识别Hibernate                Hibernate是一个开放源代码的ORM（对象关系映射）框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate                可以自动生成SQL语句，自动执行，使得我们可以随心所欲的使用对象编程思维来操纵数据库, Hibernate可以应用在任何使...
Hibernate入门学习
棉花糖老丫
05-04 1940
对象数据到关系数据映射的规则/框架/工具。ORM的优点：1.完全面向对象的编程思想，无SQL出现2.减少代码编写，提高工作效率3.提高访问数据库的性能，降低访问数据库的频率4.具有独立性，发生变化时，不会影响上层的实现Hibernate是什么？面向java环境的对象/关系数据库映射框架/工具。1. 开源免费的持久层框架.2.实现之一，建立面向对象的域和关系之间的映射.3. 对JDBC进行封装，负责java对象的持久化(CURD).
hibernate系列（一）hibernate入门
08-07
**hibernate系列（一）hibernate入门** 在Java世界中，ORM（Object-Relational Mapping，对象关系映射）框架是连接数据库与应用程序的重要桥梁，它将数据库中的数据与程序中的对象进行关联，使得开发者可以使用面向...
Struts+Spring+Hibernate快速入门
08-16
### Struts+Spring+Hibernate快速入门详解 #### 一、简介 在软件开发领域，特别是Java Web应用开发中，Struts、Spring与Hibernate是三个非常重要的框架和技术。它们各自拥有独特的功能，组合起来可以构建出高效、...
Hibernate入门案例源码
02-03
【Hibernate入门案例源码】是针对初学者设计的一份教程，旨在帮助理解并掌握Java持久化框架Hibernate的基础应用。Hibernate是一个强大的ORM（对象关系映射）框架，它简化了数据库与Java对象之间的交互，使开发者可以...
Redis篇（缓存机制 - 多级缓存）（持续更新迭代）
wlcass zhengge blog
09-30 1783
官方网站：
基于JavaScript的human-resource-backend后端开发源码设计
10-05
该项目是一款以JavaScript为主语言的HR（人力资源）后端开发源码，集成了Java、CSS、Vue和HTML等多种语言，共计1035个文件。具体文件构成如下：236个Java文件、179个JavaScript文件、104个PNG图片文件、59个CSS文件、56个Vue文件、54个GIF动画文件、42个类文件、41个XML文件、36个SVG文件、35个HTML文件。该后端系统旨在构建一个高效的人力资源管理平台。
基于Java的SpringCloud脚手架及Vue前端设计源码
最新发布
10-05
该项目是一款基于Java的SpringCloud微服务架构的脚手架，同时融合了Vue前端技术。项目包含131个文件，其中Java源代码文件50个，Vue组件文件19个，JavaScript和HTML/CSS相关文件共计38个，XML配置文件13个，YAML文件8个，JSON文件4个，图片文件3个，Git忽略配置文件2个，Markdown文件2个，HTML文件2个。项目结构清晰，功能完善，适用于快速开发和部署微服务应用。
长治医学院在辽宁2020-2024各专业最低录取分数及位次表.pdf
10-05
那些年，与你同分同位次的同学都去了哪里？全国各大学在辽宁2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值