创建hibernate项目步骤以及执行简单操作

合集下载

hibernate的基本用法

hibernate的基本用法

hibernate的基本用法Hibernate是一个开源的Java框架,用于简化数据库操作。

它为开发人员提供了一个更加简单、直观的方式来管理数据库,同时也提高了应用程序的性能和可维护性。

本文将逐步介绍Hibernate的基本用法,包括配置、实体映射、数据操作等。

一、配置Hibernate1. 下载和安装Hibernate:首先,我们需要下载Hibernate的压缩包并解压。

然后将解压后的文件夹添加到Java项目的构建路径中。

2. 创建Hibernate配置文件:在解压后的文件夹中,可以找到一个名为"hibernate.cfg.xml"的文件。

这是Hibernate的主要配置文件,我们需要在其中指定数据库连接信息和其他相关配置。

3. 配置数据库连接:在"hibernate.cfg.xml"文件中,我们可以添加一个名为"hibernate.connection.url"的属性,用于指定数据库的连接URL。

除此之外,还需要指定数据库的用户名和密码等信息。

4. 配置实体映射:Hibernate使用对象关系映射(ORM)来将Java类映射到数据库表。

我们需要在配置文件中使用"mapping"元素来指定实体类的映射文件。

这个映射文件描述了实体类与数据库表之间的对应关系。

二、实体映射1. 创建实体类:我们需要创建一个Java类,用于表示数据库中的一行数据。

这个类的字段通常与数据库表的列对应。

同时,我们可以使用Hibernate提供的注解或XML文件来配置实体的映射关系。

2. 创建映射文件:可以根据个人喜好选择使用注解还是XML文件来配置实体类的映射关系。

如果使用XML文件,需要创建一个与实体类同名的XML文件,并在其中定义实体类与数据库表之间的映射关系。

3. 配置实体映射:在配置文件中,我们需要使用"mapping"元素来指定实体类的映射文件。

Hibernate学习笔记

Hibernate学习笔记

Hibernate项目的构建与配置1.在项目里倒入Hibernate所必须的Jar包(1)Hibernate框架可以使用在任何的Java项目里,并不一定是Web项目。

只需要在项目里倒入Hibernate所必须要使用的jar包就可以了。

(2)在Hibernate的官网下载hibernate-release-4.2.2.Final.zip解压,要使用Hibernate必须导入的jar包就在目录“hibernate-release-4.2.2.Final\lib\required”下。

倒入此路径下的所有jar包就可以了。

2.配置hibernate.cfg.xml文件(1)配置hibernate.cfg.xml文件可以参考“\project\etc”目录下的hibernate.cfg.xml文件与hibernate.properties文件。

(2)使用Hibernate连接MySQL的hibernate.cfg.xml配置文件如下:<hibernate-configuration><session-factory>(设置显示Hibernate产生的SQL语句)<property name="show_sql">true</property>(设置MySQL的SQL语法的方言)<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>(设置MySQL的驱动程序)<property name="hibernate.connection.driver_class">org.gjt.mm.mysql.Driver</property>(设置MySQL的数据库路径、用户名、密码)<property name="hibernate.connection.url">jdbc:mysql:///java</property><property name="ername">root</property><property name="hibernate.connection.password">lizhiwei</property>(设置当数据库要保存的表不存在时,就新建表)<property name="hibernate.hbm2ddl.auto">update</property>(设置对象与数据库表的关系映射文件)<mapping resource="vo/User.hbm.xml"/></session-factory></hibernate-configuration>(3)此配置文件一般放在项目的src目录下。

hibernate配置

hibernate配置
属性可以是update、create和drop-create三个值。
目录
1 Hibernate概述 2 第一个Hibernate程序 3 Hibernate的配置文件 4 深入理解持久化对象 5 Hibernate的映射文件 6持久化对象 如果PO 实例与Session实例关联起来,且该实例关联到数据库的记录
脱管对象 如果PO实例曾经与Session实例关联过,但是因为Session的关闭等原 因,PO实例脱离了Session 的管理
Hibernate全面解决方案架构解释
事务(Transaction) 代表一次原子操作,它具有数据库事务的概念 但它通过抽象,将应用程序从底层的具体的JDBC、JTA和CORBA 事务中隔离开。 一个Session 之内可能包含多个Transaction对象。 所有的持久化操作都应该在事务管理下进行,即使是只读操作。
管态,对该对象操作无须锁定数据库,不会造成性能的下降。
持久化对象的状态迁移
持久化实体: 1、Serializable save(object obj) 将对象变为持久化状态 2、void persist(object obj) 将对象转化为持久化状态 3、Serializable save(object obj,object pk) 将obj对象转化为持久化状态,该对象保存到数据库,指定主键值 4、void persist(object obj,object pk) 也加了一个设定主键
Hibernate工作原理
Configuration cfg = new Configuration().configure();
开始
启动hibernate
构建Configuration 实例,初始 化该实例中的所有变量

hibernate源码分析一[启动过程]

hibernate源码分析一[启动过程]

一:关键类与接口Environment类:系统的环境变量key定义基本和hibernate.properties对应Settings类:存放系统配置信息转换的对象熟悉,比如数据库连接provider等Configuration类:系统配置信息皆在此.SessionFactory接口SessionFactoryImplSession接口SessionImplCurrentSessionContext接口ThreadLocalSessionContextConnectionProvider接口DriverManagerConnectionProvider启动代码样例:第一步:分析代码:构造器如下构造器调用一个有参数的构造器,关键是参数:SettingsFactory 构造器什么没有做,郁闷,为什么,这样?呵呵从SettingsFactory名字可以看出, Configuration是需要将配置信息的设置委托给SettingsFactory, Configuration只做自己应该做的事情就是从properties *.cfg.xml读取系统的参数.注意:这个方法可做了很多事情哦;关键是蓝色选中的地方,我们进去一探究竟;可以看出主要是获得一个properties对象,关键是这个对象的数据那里来啊?这个参数又那里来,go on!不要忘记java有个block static哦!哈哈问题在这里,jvm加载这个类的时候,就读取hibernate.properties文件,将起加载到这样回过头看reset()方法就明白了,这里主要初始化一些东西,关键是初始化hibernate.properties文件的信息.现在cfg 指向的对象的properties参数包含了hibernate.properties信息还有System.getProperties()信息!继续很简单,把这个类对应的hbm.xml文件加载,有的同学问命名参数是类,看看代码就明白了!在一个目录下且名称相同.这句是可以动态修改配置信息,其实很简单记得上面说Configuration类的properties对象吗?明白啦,就是向对象的properties对象设置key value继续方法名称可以看出.系统默认加载/hibernate.cfg.xml配置文件,会覆盖hibernate.properties文件的配置信息当然支持自己传配置文件名称,一般不会这样,没有什么大的意思?何况当使用spring管理hibernate时不需要cfg.xml文件,只需要hibernate.properties有同学问那hibernate的hbm映射文件怎么配置,可以通过spring的FactoryBean来动态加载配置给hibernate,也就是把hbm也bean化!主要是获取SessionFactory实例SessionFactoryImpl对象关键是蓝色部分通过properties信息来源hibernate.properties hibernae.cfg.xml还记得上面的那个settingsFactory对象吗[看下图]?现在用到了,呵呵!开源的代码有时间和我们想的未必一样!这个方法就是把来源hibernate.properties hibernae.cfg.xml这个的properties对象放到Settings settings = new Settings();settings对象实例buildSettings方法的上面这段代码很重要哦,几乎所以的配置信息在此都要设置给Settings 这个类的实例对象.说明session是委托给ConnectionProvider实现类获取数据库连接的的可以从配置文件配置哈!自然可以自己实现了.构造SessionFactory工程实例,获取SessionFactory使用.这个构造器有点复杂,觉得hibernate 的代码在此不爽,不过还是进去看看哦.前途是setting这个对象里面的熟悉都是配置文件转换成的java对象哦,比如ConnectionProvider实例,什么数据库支持,事物等等.Hibernate支持自己实现连接Provider类看看这个代码:呵呵如果的配置: hibernate.hbm2ddl.auto=”create”所以hibernate启动会创建数据库表,那自然需要连接数据库,那怎么获得数据库连接哈??? 不要忘记ConnectionProvider构造器只是做一些熟悉设置,把SchemaExport关系的熟悉赋值其实只是引用而已,从这里可以看书cfg ,settings这2个对象相当于上下文的主线.不过这个地方有个疑问,为什么不把setting设置给cfg?????Hibernate首先寻找private String importFile = "/import.sql";导入这个文件的sql执行生成drop的sql语句.生成建表语句.因为importFileReader是null[项目没有配置import.sql],所以没有执行import.sql接下来的代码就是检查配置文件的hql,sql数目.这个构造器还有一行特殊代码:这个代码是根据配置文件提供的hibernate.current_session_context_class的属性决定怎么处理session可以配置thread,呵呵spring也是这样的哦!我写得代码是执行所以说currentSessionContext对象实例是ThreadLocalSessionContext这个类的实例.所以当我们通过Session session=sessionFactory.getCurrentSession();得到实例session时,调用session的.所以可以看出,就是在ThreadLocalSessionContext类中有个private static final ThreadLocal context = new ThreadLocal();获取session如果当前线程没有就新建加入当前线程,有就返回此session.在得到session时间并没有获取connection[数据库连接],当你操作开始session检查事物,connection等开启当前线程结束关闭.11:16:31,906 DEBUG JDBCTransaction:82 - begin11:16:31,906 DEBUG ConnectionManager:444 - opening JDBC connection 11:16:31,906 TRACE DriverManagerConnectionProvider:133 - totalchecked-out connections: 011:16:31,906 TRACE DriverManagerConnectionProvider:139 - using pooled JDBC connection, pool size: 011:16:31,906 DEBUG JDBCTransaction:87 - current autocommit status: false 11:16:31,906 TRACE JDBCContext:237 - after transaction begin11:16:31,906 TRACE ThreadLocalSessionContext:351 - allowing proxied method [createQuery] to proceed to real session11:16:31,921 TRACE QueryPlanCache:92 - unable to locate HQL query plan in cache; generating (from Student)11:16:31,984 DEBUG QueryTranslatorImpl:269 - parse() - HQL: from com.bobo.Student11:16:32,000 DEBUG AST:289 - --- HQL AST ---\-[QUERY] 'query'\-[SELECT_FROM] 'SELECT_FROM'\-[FROM] 'from'\-[RANGE] 'RANGE'\-[DOT] '.'+-[DOT] '.'| +-[IDENT] 'com'| \-[IDENT] 'bobo'\-[IDENT] 'Student'11:16:32,000 DEBUG ErrorCounter:91 - throwQueryException() : no errors11:16:32,046 DEBUG HqlSqlBaseWalker:111 - select << begin [level=1, statement=select]11:16:32,062 DEBUG FromElement:129 - FromClause{level=1} :com.bobo.Student (no alias) -> student0_11:16:32,062 DEBUG HqlSqlBaseWalker:117 - select : finishing up [level=1, statement=select]11:16:32,062 DEBUG HqlSqlWalker:531 - processQuery() : ( SELECT( FromClause{level=1} AuctionUser student0_ ) )11:16:32,078 DEBUG HqlSqlWalker:738 - Derived SELECT clause created. 11:16:32,078 DEBUG JoinProcessor:171 - Using FROM fragment [AuctionUser student0_]11:16:32,078 DEBUG HqlSqlBaseWalker:123 - select >> end [level=1, statement=select]11:16:32,078 DEBUG AST:255 - --- SQL AST ---\-[SELECT] QueryNode: 'SELECT' querySpaces (AuctionUser)+-[SELECT_CLAUSE] SelectClause: '{derived select clause}'| +-[SELECT_EXPR] SelectExpressionImpl: 'student0_.id as id0_' {FromElement{explicit,not a collection join,not a fetch join,fetchnon-lazyproperties,classAlias=null,role=null,tableName=AuctionUser,tableAlias=student0_,origin=null,colums={,className=com.bobo.Student}}}| \-[SQL_TOKEN] SqlFragment: 'student0_.no as no0_'\-[FROM] FromClause: 'from' FromClause{level=1, fromElementCounter=1, fromElements=1, fromElementByClassAlias=[],fromElementByTableAlias=[student0_], fromElementsByPath=[], collectionJoinFromElementsByPath=[], impliedElements=[]}\-[FROM_FRAGMENT] FromElement: 'AuctionUser student0_' FromElement{explicit,not a collection join,not a fetch join,fetchnon-lazyproperties,classAlias=null,role=null,tableName=AuctionUser,tableAlias=student0_,origin=null,colums={,className=com.bobo.Student}}11:16:32,078 DEBUG ErrorCounter:91 - throwQueryException() : no errors 11:16:32,093 DEBUG QueryTranslatorImpl:239 - HQL: from com.bobo.Student 11:16:32,093 DEBUG QueryTranslatorImpl:240 - SQL: select student0_.id as id0_, student0_.no as no0_ from AuctionUser student0_11:16:32,093 DEBUG ErrorCounter:91 - throwQueryException() : no errors 11:16:32,109 TRACE HQLQueryPlan:293 - HQL param location recognition took 16 mills (from Student)11:16:32,109 TRACE ThreadLocalSessionContext:351 - allowing proxied method [getTransaction] to proceed to real session11:16:32,109 DEBUG JDBCTransaction:134 - commit11:16:32,109 TRACE SessionImpl:365 - automatically flushing session 11:16:32,109 TRACE JDBCContext:228 - before transaction completion11:16:32,109 TRACE SessionImpl:421 - before transaction completion 11:16:32,109 DEBUG JDBCTransaction:147 - committed JDBC Connection 11:16:32,109 TRACE JDBCContext:242 - after transaction completion11:16:32,109 DEBUG ConnectionManager:427 - aggressively releasing JDBC connection11:16:32,109 DEBUG ConnectionManager:464 - releasing JDBC connection [ (open PreparedStatements: 0, globally: 0) (open ResultSets: 0, globally: 0)]11:16:32,109 TRACE DriverManagerConnectionProvider:178 - returning connection to pool, pool size: 111:16:32,109 TRACE SessionImpl:450 - after transaction completion11:16:32,109 TRACE SessionImpl:381 - automatically closing session 11:16:32,109 TRACE SessionImpl:301 - closing session11:16:32,109 TRACE ConnectionManager:398 - connection already null in cleanup : no action简单总节:Hibernate启动读取hibernate.properties hiernate.cfg.xml文件初始化(properties对象放在Configuration实例对象中同时实例化Settings对象存放,Envriment类似环境的key集合)通过这个觉得做什么操作,包括配置文件加载,是不是执行建表语句.Session获取是通过CurrentSessionContext接口的实例得到具体那个实例根据配置文件.。

搭建SSH框架(Struts1,Spring2.5,Hibernate3)

搭建SSH框架(Struts1,Spring2.5,Hibernate3)

搭建SSH框架:Struts1.* + Spring2.5 + Hibernate3.0 一,项目结构:图(1)Jsp页面省略,主要是一些添删改查的页面;二,开始搭建项目环境,步骤如下:使用平台:MyEclipse6.0/6.5框架版本:Struts1.* + Spring2.5 + Hibernate3.0;1,添加过程:1>,新建项目: 打开MyEclipse,在Package Explorer视图下,右键单击New-> Web Project;注意:在新建项目时,JDK的版本最好要选择Java EE 5.0;因为版本过低,可能有些JSP方面的功能不支持;新建玩项目之后,把该导的包导入到下面,下图为SS H 框架所需要的Jar包,注意,该项目用的是ORACLE数据库;其中,activation与mail这两个包为Java发邮件的包;classes12为Oracle数据库的驱动包,如果不是Oracle数据库,可更换该Jar包;dwe为Ajax dwr 框架中的包;2>,接着就开始用MyEclipse辅助开发Struts,Spring,Hibernate了;3>,首先MyEclipse辅助开发Struts,方法:右键单击你所建的项目,出现一级菜单,选择Myeclipse,选择Myeclipse之后会出现二级菜单,接着选择Add Struts Capabilities;;接着具体操作如下面图示:点击Finish按钮完成;完成之后,可将包删除;在上图中,如果那个勾没有去掉的话,就会自动生产如下标签:当然,如果你觉得标签对你没什么用的话,可以删除;如果该勾去掉的话,就只生成标签,这是Struts的核心标签;4>,MyEclipse辅助开发Spring,方法跟上面的一样,选择Add Spring apabilities;;接着具体操作如下面图示:然后点击Next,具体操作如下图:接着点击 Finish按钮,完成此项操作;5>,,最后MyEclipse辅助开发Hibernate,在执行和上面类似方法之前,Hibernate 需要先做另外一件事情,那就是和数据建立连接,具体操作如下图:点击上图位置的或者右边的>> ,然后再选择MyEclipse Database Explorer切换到如下图页面:,然后右键单击,新建一个Database Driver;如下图:下面这个截图是该项目的数据库链接图:如图所示,测试数据库链接成功;然后可直接点击Finish完成;接着切换到窗口,按照上面第三小步的方法,选择Add Hibernate apabilities;;接着具体操作如下面图示:点击下一步:点击下一步:点击下一步:点击下一步:点击 Finish 完成;6>,最后一步,就是运用Hibernate的映射机制,把数据库的表与JAVA的对形成一个关系映射;在此之前,首先应该在项目SRC的目录下面新建一个包,如该项目所示,用来存放映射生成的POJO对象以及映射文件;如下图:有一点说一下,你生成的*.hbm.xml文件可能不止一个,对,你可以把它们整合到一个文件中;然后新建按第五小步的方法,把窗口切换到MyEclipse Database Explorer界面,然后打开右键刚才所建立的链接,选择属于你自己的用户;然后选择Tble;右键选择如上图的属性:接下来的操作如下图:点击 Next,进入下一步:点击 Next,进入下一步:至此,项目环境己经搭建完成;三,项目搭建完成,SSH各个部分配置文件的说明,以及它们之间存在的关系:1,首先是Struts的核心配置文件,即struts-config.xml:<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.2//EN""/dtds/struts-config_1_2.dtd"><struts-config><data-sources /><form-beans><!—建立Form表单,在此处进行登记 -→<form-bean name="userForm"type="erForm" /> </form-beans><global-exceptions /><global-forwards /><!—各个Action对应与之相对应的表单 -→<action-mappings><!-- 用户管理 --><action parameter="opers" attribute="userForm" name="userForm"path="/doUser" scope="request"><forward name="login_ok" path="/welcome.jsp"></forward><forward name="login_no" path="/index.jsp"></forward> </action></action-mappings><controllerprocessorClass="org.springframework.web.struts.DelegatingRequestProc essor"></controller><message-resourcesparameter="ermanagerview.struts.ApplicationResources"> </message-resources><!—Spring辅助Struts管理Struts-→<plug-inclassName="org.springframework.web.struts.ContextLoaderPlugIn"><set-property property="contextConfigLocation"value="/WEB-INF/action-servlet.xml" /></plug-in></struts-config>2,其次就是Springd的applicationContext.xml文件和action-servlet.xml文件:applicationContext.xml文件:<?xml version="1.0" encoding="UTF-8"?><beansxmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-2.5.xsd"><!-- Session 工厂 --><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation"value="classpath:hibernate.cfg.xml"><!-- 可以不要配置文件(hibernate.cfg.xml),直接写在这个Spring的配置文件中 --></property></bean><!-- 模板 --><bean id="hibernateTemplate"class="org.springframework.orm.hibernate3.HibernateTemplate"><property name="sessionFactory" ref="sessionFactory" /> </bean><!-- 事务器 --><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManage r"><property name="sessionFactory" ref="sessionFactory" /> </bean><!-- 对外代理 --><!-- 1,用户管理 --><bean id="userDaoImp"class="erDaoImp"><property name="hibernateTemplate" ref="hibernateTemplate" /> </bean><bean id="userServiceTarget"class="erServiceImp"> <property name="userdao"><ref local="userDaoImp" /></property></bean><bean id="userService"class="org.springframework.transaction.interceptor.TransactionProxyF actoryBean"><property name="transactionManager"><ref local="transactionManager" /></property><property name="target"><ref local="userServiceTarget" /></property><property name="transactionAttributes"><props><prop key="*">PROPAGATION_REQUIRED</prop></props></property></bean></beans>action-servlet.xml文件:<!—Spring辅助Struts管理Struts-<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-2.0.xsd"> <bean name="/doUser"class="erAction"scope="prototype"></bean></beans>3,最后就是Hibernate的hibernate.cfg..xml文件:<?xml version='1.0' encoding='UTF-8'?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/hibernate-configuration-3.0.dtd"><!-- Generated by MyEclipse Hibernate Tools. --><hibernate-configuration><session-factory><property name="ername">wangxiaodong</property><property name="connection.url">jdbc:oracle:thin:@192.168.0.2:1521:ALIZEEDB</property><property name="dialect">org.hibernate.dialect.Oracle9Dialect</property><propertyname="myeclipse.connection.profile">Test</property><property name="connection.password">donny</property><property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property><mappingresource="com/ygkq/usermanager/model/entity/User.hbm.xml" /></session-factory></hibernate-configuration>该文件基本上不用动,都是自动生成的代码;当然,你也可以根据自己的需要添加代码,例如,你想在执行HQL语句的时候让它显示SQL语句,可将<property name="hibernate.show_sql">true</property>插入代码中;另外在图(1)中还有两个配置文件没有提到,那就是log4j.properties 与mytag.tld;其中log4j.properties是配置日志信息的;而mytag.tld主一个自定义标签;四,SSH框架搭建完成:SSH框架基本搭建完成,如果有不对或者不妥之处,请随时指教!~E-mail:jerry8059@。

hibernate框架的工作原理

hibernate框架的工作原理

hibernate框架的工作原理Hibernate框架的工作原理Hibernate是一个开源的ORM(Object-Relational Mapping)框架,它将Java对象映射到关系型数据库中。

它提供了一种简单的方式来处理数据持久化,同时也提供了一些高级特性来优化性能和可维护性。

1. Hibernate框架的基本概念在开始讲解Hibernate框架的工作原理之前,需要先了解一些基本概念:Session:Session是Hibernate与数据库交互的核心接口,它代表了一个会话,可以用来执行各种数据库操作。

SessionFactory:SessionFactory是一个线程安全的对象,它用于创建Session对象。

通常情况下,应用程序只需要创建一个SessionFactory对象。

Transaction:Transaction是对数据库操作进行事务管理的接口。

在Hibernate中,所有对数据库的操作都应该在事务中进行。

Mapping文件:Mapping文件用于描述Java类与数据库表之间的映射关系。

它定义了Java类属性与数据库表字段之间的对应关系。

2. Hibernate框架的工作流程Hibernate框架主要分为两个部分:持久化层和业务逻辑层。

其中,持久化层负责将Java对象映射到数据库中,并提供数据访问接口;业务逻辑层则负责处理业务逻辑,并调用持久化层进行数据访问。

Hibernate框架的工作流程如下:2.1 创建SessionFactory对象在应用程序启动时,需要创建一个SessionFactory对象。

SessionFactory是一个线程安全的对象,通常情况下只需要创建一个即可。

2.2 创建Session对象在业务逻辑层需要进行数据访问时,需要先创建一个Session对象。

Session是Hibernate与数据库交互的核心接口,它代表了一个会话,可以用来执行各种数据库操作。

2.3 执行数据库操作在获取了Session对象之后,就可以执行各种数据库操作了。

hibernate实验手册

hibernate实验手册

目录新建数据库和表在数据库test 中创建student 表格创建 HibernateDemo Java Project新建一个Java Project命名为:HibernateDemo添加Hibernate Capabilities 到现有项目像添加Spring和Struts支持一样,给项目添加Hibernate Capabilities点击”next”再点击”next”选择好“DB Driver”点击“next”新建一个package得到:点击“Finish”使用反向工程快速生成Java POJO 类,映射文件和DAO找到DB Browser选择我们创建的student表右键点击出现下图:选择“Hibernate Reverse Engineering”出现:在Java Package那里通过“Browser”找到项目的dao包按顺序将要打勾的地方打上勾点击1 处的Java src folder 最右侧的Browse 按钮,查看可用的Hibernate 项目以及源码目录,这些目录将用来存放最终生成的文件。

这里选中HibernateDemo 项目中的src 文件夹.。

点击2 处的Java package 输入框右侧的Browse 按钮,选中dao 包,或者新建一个其它的包来存放生成的代码所在的包。

将3 中的两个复选框选中,这样将为每个数据库表生成Hibernate 映射文件(*.hbm.xml),并在hibernate.cfg.xml 中将新生成的映射文件加入。

在4 中选中复选框Java Data Object(POJO <> DB Table),这样为映射文件和表格生成对应的数据对象(POJO)。

按照图示选中5 处的复选框,这样将能生成普通的DAO 类。

点击“Finish”看到:编写测试类在项目文件夹中新建一个类:学写第一个HQL语句如下图在HQL 1 中输入“From Student s where s.id = 1”。

eclipse中,由数据库反向生成hibernate实体类(图解)

eclipse中,由数据库反向生成hibernate实体类(图解)

Eclipse中反向生成hibernate实体类+jpa注释2011-01-24一、配置数据源,sqlServer2000数据库1、菜单栏“Window”……,截图如下:2、Database Connecttions右击“new”,选择要使用的数据库,本例中是SQL Server,给数据源随便命名,此处为MedicalInfoDB,然后单击“next”,截图如下:3、单击Drivers一行最后那个按钮,配置数据库驱动:配置驱动类和url等……最后点击“OK”,截图如下:4、点击“OK”之后,配置“General”选项卡,“Optional”选项卡不用管,截图如下,5、然后点击“Next”,核对一下数据源信息,点击“Finish”。

截图如下:6、二、反向生成实体类1、打开eclipse,在顶部菜单栏右击选择“Customize Per……”,截图如下:2、选择之后弹出如下选项卡,选择“Command Groups A vailability”,在下面勾选“Hibernate Code Generation”,然后点击“OK”,截图如下:3、点击“OK”之后会在菜单栏中显示如下图所示最后一个快捷按钮:4、点击按钮右边的小箭头,选择下拉菜单中第二项“Hibernate Code Generation……”,截图如下:5、选中之后,弹出如下窗口,右击“New”一个New_configuration:6、左键单击选中新建的New_configuration,右边出现好多选项卡,截图如下:参数说明:(1)、没用;(2)、选择保存……的位置。

(3)、如果反向生成实体类,则将勾上。

保存实体类的文件夹的位置(可不填写),Reveng.xml最右边的Setup……,点击后“新建”或者“使用已存在的”reveng.xml。

选择保存reveng.xml文件的项目的包,点击“Next”,然后点击,单击选中要使用的数据库,或者数据库的某些表(包括表和视图!!!),点击,然后“Finish”。

一个hibernate登录注册工程

一个hibernate登录注册工程

一个hibernate登录注册工程HibernateMySQLJSPXMLSQL项目名称:loginandregister.其目录:loginandregister|----src| -----hibernate.yan| -----LoginServlet.java |-----RegisterServlet.java | ---- User.java| -----WriterDB.java| -----user.hbm.xml| -----hibernate.cfg.xml|----jre sytem library|---J2EE 1.4 Library|---Referenced Library|---WebRoot|----Weta-inf|----WEB-INF|----lib|-----web.xml|-----login.jsp|-----register.jsp新建web project,命名为loginandregister,右击工程名,Myeclispe—>Add hibernate capabilities将hibernate的jar包加入,当然也可以通过项目属性—>构建路径,加入。

web.xml内容为:<?xml version="1.0" encoding="UTF-8"?><web-app version="2.4"xmlns="/xml/ns/j2ee"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/xml/ns/j2ee/xml/ns/j2ee/web-app_2_4.xsd"><welcome-file-list><welcome-file>login.jsp</welcome-file></welcome-file-list><servlet><servlet-name>RegisterServlet</servlet-name><servlet-class>hibernate.yan.RegisterServlet</servlet-class></servlet><servlet-mapping><servlet-name>RegisterServlet</servlet-name><url-pattern>/RegisterServlet</url-pattern></servlet-mapping><servlet><servlet-name>LoginServlet</servlet-name><servlet-class>hibernate.yan.LoginServlet</servlet-class></servlet><servlet-mapping><servlet-name>LoginServlet</servlet-name><url-pattern>/LoginServlet</url-pattern></servlet-mapping></web-app>user.hbm.xml内容为:<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"><hibernate-mapping><class name="er" table="user"><id name="id"><generator class="identity" /></id><property name="name" type="string" ><column name="name"></column></property><property name="password" type="string" ><column name="password"></column></property><property name="phonetype" type="int" ><column name="phonetype"></column></property></class></hibernate-mapping>hibernate.cfg.xml为:<?xml version='1.0' encoding='gbk'?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/hibernate-configuration-3 .0.dtd"><!-- Generated by MyEclipse Hibernate Tools.--><hibernate-configuration><session-factory><!--统一设置成UTF-8编码--><propertyname="dialect">org.hibernate.dialect.MySQLDialect</property><propertyname="connection.url">jdbc:mysql://localhost/lrdatabase?useUnicode=tr ue&amp;characterEncoding=UTF-8</property><property name="ername">root</property><property name="connection.password">123456</property><propertyname="connection.driver_class">com.mysql.jdbc.Driver</property><!--一些可选性能参数设置--><!-- Enable Hibernate's automatic session context management--><property name="current_session_context_class">thread</property><!-- Disable the second-level cache --><property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property><!-- Echo all executed SQL to stdout --><property name="show_sql">true</property><mapping resource="hibernate/yan/user.hbm.xml" /></session-factory></hibernate-configuration>login.jsp:<%@ page language="java" contentType="text/html; charset=utf-8"pageEncoding="utf-8"%><%request.setCharacterEncoding("GBK"); %><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "/TR/html4/loose.dtd"><html><head><meta http-equiv="Content-Type" content="text/html; charset=utf-8"> <title>登录页面</title></head><body><form action="<%=request.getContextPath() %>/LoginServlet"> <table align="center" border=0 width="400" height="100" cellspacing="0"><tr align="center"><td>用户登录</td></tr><tr><td><font size="5">username:</font></td><td><input type="text" name="username"/></td></tr><tr><td><font size="5">password:</font></td><td><input type="password" name="password"/></td></tr><tr><td><input type="submit" name="login" value="login"/></td> <td><a href="register.jsp" target="_blank">注册</a></td></tr></table></form></body></html>register.jsp:<%@ page language="java" contentType="text/html; charset=utf-8"pageEncoding="utf-8"%><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN""/TR/html4/loose.dtd"><html><head><meta http-equiv="Content-Type" content="text/html; charset=utf-8"> <title>注册页面</title></head><body><span >注册</span><form id="form1" name="form1" method="post"action="<%=request.getContextPath() %>/RegisterServlet"><table align="center" width="571" height="165"border="0" cellspacing="0" ><tr><td>请输入名称:</td><td><input name="name" type="text"></td></tr><tr><td>请输入密码:</td><td><input name="password" type="text"></td></tr><tr><td>请选择手机型号:</td><td><select name="phonetype" ><option value="1">phone1</option><option value="2">phone2</option><option value="3">phone3</option></select></td></tr></table><div align="center"><input name="submit" type="submit" value="submit" /></div></form></body></html>loginServlet.java:public class LoginServlet extends HttpServlet {protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {// TODO Auto-generated method stubdoPost(req, resp);}protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {// TODO Auto-generated method stubresp.setContentType("text/html;charset=utf-8");String name=req.getParameter("username");String ssname = new String(name.getBytes("iso-8859-1"),"utf-8");System.out.println("ss=:" + ssname);String password=req.getParameter("password");Transaction tx=null;Session session=null;PrintWriter out=resp.getWriter();String sql="from User where name='"+ssname+"' andpassword='"+password+"'";if(true){try{Configuration conf=new Configuration().configure();SessionFactory sf=conf.buildSessionFactory();session=sf.openSession();tx=session.beginTransaction();System.out.println(sql);Query query=session.createQuery(sql);List list=(List) query.list();mit();Iterator it=list.iterator();if(it.hasNext()){User user=(User) it.next();System.out.println(user.getName()+" "+user.getPassword()+" "+user.getPhonetype());out.println("<html>");out.println("<head><title>login</title></title>");out.println("<body>");out.println("successfully login:name:"+user.getName()+" password:"+user.getPassword()+" phonetype:"+user.getPhonetype());out.println("</body></html>");out.close();}else{out.println("<html>");out.println("<head><title>login</title></title>");out.println("<body>");out.println("不存在此用户信息");out.println("</body></html>");out.close();}}catch(Exception e){e.printStackTrace();}}else{out.println("<html>");out.println("<head><title>login</title></title>");out.println("<body>");out.println("请输入信息完整");out.println("</body></html>");out.close();}}}RegisterServlet.javapublic class RegisterServlet extends HttpServlet {protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {// TODO Auto-generated method stubdoPost(req, resp);}protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {// TODO Auto-generated method stubresp.setContentType("text/html;charset=utf-8");String name=req.getParameter("name");String password=req.getParameter("password");String phonetype=req.getParameter("phonetype");String ssname = new String(name.getBytes("iso-8859-1"),"utf-8");System.out.println(ssname+" "+password);//int numofphonetype=Integer.getInteger(phonetype).intValue();//这句话导致异常int a=Integer.parseInt(phonetype);PrintWriter out=resp.getWriter();try{if(ssname!=""&&password!=""&&phonetype!=""){WriteDB writer=new WriteDB();writer.WriteLogToDB(ssname, password, a);out.print("注册成功");}else{out.print("请填写完整!");}}catch(Exception e){out.print("Error :"+e.getMessage());}}public void destroy() {// TODO Auto-generated method stubsuper.destroy();}public void init() throws ServletException {// TODO Auto-generated method stubsuper.init();}}WriterDB.javapublic class WriteDB {public static SessionFactory sf;static {try{Configuration conf=new Configuration().configure();sf=conf.buildSessionFactory();System.out.println("sf=conf.buildSessionFactory()");}catch(Exception e){e.printStackTrace();}}public void WriteLogToDB(String name,String password,int phonetype) {User user=new User();user.setName(name);user.setPassword(password);user.setPhonetype(phonetype);Session sessions=sf.openSession();Transaction tran=null;try{tran=sessions.beginTransaction();sessions.save(user);mit();//提交// System.out.println("已正常提交数据:"+con.getId()+" ,"+con.getLogcontent()+" ,"+con.getLogdate());}catch(Exception e){if(tran!=null){tran.rollback();}}finally{sessions.close();}}}User.javapublic class User {private int id;private String name;private String password;private int phonetype;public User() {}public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}public String getPassword() {return password;}public void setPassword(String password) { this.password = password;}public int getPhonetype() {return phonetype;}public void setPhonetype(int phonetype) {this.phonetype = phonetype;}}数据库脚本:/*MySQL Data TransferSource Host: localhostSource Database: lrdatabaseTarget Host: localhostTarget Database: lrdatabaseDate: 2010-4-1 14:51:51*/SET FOREIGN_KEY_CHECKS=0;-- ------------------------------ Table structure for user-- ----------------------------CREATE TABLE `user` (`id` int(11) NOT NULL AUTO_INCREMENT,`name` varchar(20) CHARACTER SET utf8 DEFAULT NULL,`password` varchar(20) CHARACTER SET utf8 DEFAULT NULL, `phonetype` tinyint(11) DEFAULT NULL,PRIMARY KEY (`id`)) ENGINE=InnoDB AUTO_INCREMENT=11 DEFAULT CHARSET=utf-8;。

项目搭建步骤

项目搭建步骤

项目搭建步骤一、前言项目的搭建是一个非常重要的环节,关系到项目的运行效率及安全性。

本文将介绍项目搭建的步骤,以供开发人员参考。

二、项目搭建前准备在项目搭建之前,需要对环境进行准备,具体如下:1.选择适合的开发工具开发工具的选择是非常重要的,可以提高开发效率,减少出错概率。

在选择开发工具时,需要考虑到语言和项目类型,例如Java项目可以使用Eclipse或者IntelliJ IDEA等IDE,而前端项目可以使用WebStorm或Visual Studio Code等工具。

2.安装必要的软件根据项目需要,安装必要的软件。

例如,Java项目需要安装JDK,Web项目需要安装Web服务器等等。

3.搭建开发环境对于Java项目,需要搭建开发环境,例如配置环境变量,设置Java_home等。

三、项目搭建步骤1.新建项目选中开发工具,点击New Project按钮,进入新建项目的页面。

根据项目类型,选择需要新建的项目类型,并填写相关信息,例如项目名称、项目路径等。

2.添加框架根据项目类型和需要,选择合适的框架,并将其添加到项目中。

例如,对于Java项目可以使用Spring、Hibernate等框架,对于前端项目可以使用React、Vue等框架。

3.配置项目根据项目需要,进行配置,例如配置数据库连接、配置服务器等。

4.编写代码根据项目需求,开始编写代码。

对于Java项目,可以创建Controller、Service、Dao等层次,对于前端项目可以开始编写页面、组件等。

5.测试与调试完成代码编写后,需要进行测试和调试。

可以使用单元测试工具、调试工具等进行测试和调试。

6.打包完成测试和调试后,对于Java项目需要进行打包,生成可执行的Jar包或War包等。

7.发布将打好包的项目通过FTP等方式上传到服务器并启动即可。

四、项目搭建注意事项1.项目搭建需要按照步骤进行,不要省略或乱序。

2.选择开发工具和框架时,需要考虑项目类型和需求。

整合struts1+spring+hibernate框架完成简单的登录

整合struts1+spring+hibernate框架完成简单的登录

*编写环境:*开发工具:Myeclipse6.01*SPRING :spring2.0*STRUTS :struts1.2*HIBERNATE:hibernate3.0*JDK: 1.6*TOMCAT: 6.0*WINDOW641.新建web项目。

2.选中新建项目,右键--》选择“myeclipse”--》添加Struts支持。

3.在弹出的信息框,有必要修改一下图中的地方。

4.上面的操作完成之后,打开我们的项目我们可以看到我们的项目结构发生了变化,引入了一些struts标签和生成了struts-config.xml配置文件。

5.开始添加spring支持,同样选中新建项目,右键--》选择“myeclipse”--》“添加spring 支持”,在弹出的信息框,做如下内容修改:6.点击“next”,直接选择默认,当然也可根据自己的规则做修改。

7.在添加“Hibernate”支持的时候,首先做的工作是创建一个数据源。

这个创建方法有很多中(找百度可得)这里只介绍一种:打开你的myeclipse的右上角的小三角,选择“myeclipsedatabase explorer”在弹出的界面中,在如图位置右键“new”在弹出的界面中做如下修改:修改完成后点击“test driver”成功则继续。

8.暂时回到myeclipse开发界面。

正式开始添加“Hibernate”支持。

在弹出的界面中做如图修改:点击“next”这里如图,选择spring的配置文件。

下一步操作后,做如下图修改操作:下一步之后,界面修改操作,如下图:去掉复选框中的选项,然后点击“finish”完成整个操作。

之后将会直接打开spring的配置文件,然后你核对一下您的数据库连接是否正确。

至此三大支持操作完成,启动没有问题说明框架雏形已经完成。

9.在项目中的WEB-INF下找到web.xml,做如下修改:格式头部分省略,下面是需要新增的代码<!--初始化spring配置参数 --><context-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext.xml</param-value></context-param><!-- 配置监听 --><listener><listener-class>org.springframework.web.context.ContextLoaderListener</list ener-class></listener><!-- 配置spring过滤器解决中文乱码问题 --><filter>Ps :这个时候我们再次启动服务的时候,发现可能会报错:因为我们在刚才已经把spring 的配置文件做了初始化,而在spring 的配置文件中有数据源的连接,而我们的项目中可能还缺少一个包:commons-pool-1.4.jar(/detail/u013806366/7897665 )当我们把这个包放在lib 下,我们再次启动项目的时候,错误信息应该会消失。

简述hibernate查询数据库的步骤

简述hibernate查询数据库的步骤

简述hibernate查询数据库的步骤Hibernate是一个开源的Java持久化框架,它可以帮助开发者简化数据库操作,提高开发效率。

在Hibernate中,查询数据库是非常常见的操作,本文将以标题的方式,简述Hibernate查询数据库的步骤。

一、配置Hibernate在开始使用Hibernate查询数据库之前,首先需要进行Hibernate 的配置工作。

包括创建Hibernate配置文件(hibernate.cfg.xml),配置数据库连接信息、数据库方言等。

同时,还需要配置实体类与数据库表之间的映射关系(Hibernate映射文件)。

二、创建SessionFactorySessionFactory是Hibernate的核心接口之一,它负责创建Session对象,是实现Hibernate查询的基础。

在Hibernate中,SessionFactory是线程安全的,通常一个应用程序只需要一个SessionFactory实例。

三、打开Session在进行数据库查询之前,需要先打开一个Session。

Session是Hibernate中的一个重要概念,它代表一个与数据库的会话。

可以通过SessionFactory的openSession方法来打开一个Session。

四、开始事务在进行数据库查询操作之前,通常需要开启一个事务。

通过调用Session的beginTransaction方法,开始一个事务。

事务的开启可以保证数据的一致性和完整性。

五、执行查询操作在Hibernate中,有多种查询方式可以选择。

常见的查询方式包括HQL查询、QBC查询和Native SQL查询。

HQL(Hibernate Query Language)是Hibernate提供的一种面向对象的查询语言,类似于SQL语句。

QBC(Criteria Query)是一种基于Criteria的查询方式,可以通过CriteriaBuilder来构建查询条件。

JavaEE练习题(附答案)

JavaEE练习题(附答案)

一、名词解释(共5小题每题3分,共15分)1、MVC :Model、View和Controller,是一个设计模式,它强制性地使应用程序的输入、处理和输出分开,三个部分以最小的耦合协同工作,以增加程序的可扩展性和可维护性;2、OGNL:Object Graphic Navigation Language(对象图导航语言),是一个开源项目,是一种功能强大的EL(表达式语言),可通过简单的表达式来访问Java对象中的属性;3、持久化:即把数据(如内存中的对象)保存到可永久保存的存储设备中(如磁盘),是将程序数据在持久状态和瞬时状态间转换的机制;4、ORM:对象关系映射,是用于将对象与对象之间的关系对应到数据库表与表之间关系的一种模式;5、通知(Advice):定义了切面中的实现类型是指在定义好的切入点处所有执行的程序代码;6、事务:是工作中的基本逻辑单位,可以用于确保数据库能够被正确修改,避免数据只修改了一部分而导致数据不完整,或者在修改时受到用户干扰;7、POJO类:POJO(Plain Old Java Objects)简单的Java对象,实际就是普通JavaBeans,是为了避免和EJB混淆所创造的简称,它通指没有使用Entity Beans的普通java对象,可以把POJO作为支持业务逻辑的协助类。

8、AOP:面向切面编程,可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术;9、IoC:Inversion of Control(控制反转),是一个重要的面向对象编程的法则来削减计算机程序的耦合问题,IoC的基本概念是不创建对象,但是描述创建它们的方式,在代码中不直接与对象和服务连接,但在配置文件中描述哪一个组件需要哪一项服务。

容器负责将这些联系在一起;10、HQL:Hibernate Query Language的缩写,HQL的语法很像SQL,但HQL是一种面向对象的查询语言,操作的对象是类、实例、属性等。

hibernatetemplate 语法

hibernatetemplate 语法

hibernatetemplate 语法摘要:一、介绍HibernateTemplate 语法二、HibernateTemplate 的优势三、HibernateTemplate 的使用方法四、HibernateTemplate 的常见方法五、HibernateTemplate 的注意事项六、总结正文:HibernateTemplate 是Hibernate 框架中的一个核心类,它提供了一种简化Hibernate 操作的语法。

HibernateTemplate 可以帮助我们简化Hibernate 的增删改查操作,使开发者无需手动编写SQL 语句,只需使用HibernateTemplate 类的方法即可完成相应的操作。

HibernateTemplate 的优势在于它提供了一种更符合面向对象编程思想的操作方式。

通过HibernateTemplate,我们可以将业务逻辑与数据访问逻辑分离,使代码结构更加清晰。

同时,HibernateTemplate 还具有自动事务管理功能,可以有效地管理事务,避免出现因事务处理不当而引发的问题。

使用HibernateTemplate 非常简单,首先需要创建一个HibernateTemplate 对象,然后通过这个对象调用相应的方法进行操作。

下面是一个简单的示例:```java// 获取HibernateTemplate 对象Session session = HibernateUtil.getSessionFactory().openSession();HibernateTemplate hibernateTemplate = new HibernateTemplate(session);// 使用HibernateTemplate 插入数据User user = new User();user.setName("张三");user.setAge(25);hibernateTemplate.insert(user);// 使用HibernateTemplate 更新数据User user2 = (User) hibernateTemplate.load(User.class, 1);user2.setName("李四");hibernateTemplate.update(user2);// 使用HibernateTemplate 删除数据hibernateTemplate.delete(user);// 使用HibernateTemplate 查询数据List<User> users = hibernateTemplate.loadAll(User.class);```HibernateTemplate 提供了许多常用的方法,如insert、update、delete、load、loadAll 等,可以满足我们日常开发中的大部分需求。

Hibernate

Hibernate
有两种手动干预内部缓存的方法:
a. Session.evict
将某个特定对象从内部缓存中清楚
b. Session.clear
清空内部缓存
当批量插入数据时,会引发内存溢出,这就是由于内部缓存造成的。例如:
For(int i=0; i<1000000; i++){
For(int j=0; j<1000000; j++){
session.iterate(…)方法和session.find(…)方法的区别:session.find(…)方法并不读取ClassCache,它通过查询语句直接查询出结果数据,并将结果数据put进classCache;session.iterate(…)方法返回id序列,根据id读取ClassCache,如果没有命中在去DB中查询出对应数据。
User user = new User();
user.setUserName(“gaosong”);
user.setPassword(“123”);
session.save(user);
}
}
在每次循环时,都会有一个新的对象被纳入内部缓存中,所以大批量的插入数据会导致内存溢出。解决办法有两种:a 定量清除内部缓存 b 使用JDBC进行批量导入,绕过缓存机制。
user.setLoginName("jonny");
mit();
session2 .close();
这种方式,关联前后是否做修改很重要,关联前做的修改不会被更新到数据库,
比如关联前你修改了password,关联后修改了loginname,事务提交时执行的update语句只会把loginname更新到数据库

Springboot项目搭建(前端到数据库,超详细)

Springboot项目搭建(前端到数据库,超详细)

Springboot项⽬搭建(前端到数据库,超详细)下⾯详细谈谈我的第⼀个springboot项⽬搭建,希望会给还在摸索的同学⼀点帮助。

项⽬说明:开发环境:Eclipse 4.42框架:Springboot⼯具:Maven前端:Html、Thymeleaf后台:Java、JPA (Hibernate)数据库:Mysql为什么要搭建Springboot项⽬?教科书式的阐述这⾥就不说了,我就总结为两个词语 “简单、⽅便”。

为了更加清晰的展⽰,现在我⽤⼀个全新的⼯作空间来演⽰springboot项⽬的搭建过程。

【01】创建⼀个简单的maven项⽬(如果Eclipse不⽀持Maven项⽬创建,请先⾃⾏安装Maven,不会问度娘):(1.1)右键单击 --> New --> Other(1.2)输⼊Maven,选中Maven Project,点击Next。

(1.3)勾选 Use default Workspace location,点击Next。

(1.4)选择 maven-archetype-quickstart,点击Next。

⽬中的包名,点击Finish。

(1.6)可以看到,我们的⼯程已经创建成功了。

但貌似现在有⼀些不完美的地⽅需要解决。

(1.7)⼯程创建成功后,可以看到⼜⼀个⼩红叉,虽然不影响程序运⾏,但⾯对有强迫的我们,看着很少难受。

选中⼯程:右键单击--> Maven --> Update Project(1.8)什么都不管,直接点击OK(1.9)奈斯!⼩红叉已经被我们消灭了!【02】加⼊Springboot框架(2.1)我们先双击打开pom.xml⽂件,把不要的东西先⼲掉,最后保留如下所⽰即可:<project xmlns="/POM/4.0.0" xmlns:xsi="/2001/XMLSchema-instance" xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com</groupId><artifactId>springboot</artifactId><version>0.0.1-SNAPSHOT</version><packaging>jar</packaging></project>(2.2)定义⽗类:springboot 所有jar包版本,这⾥为 2.0.5.RELEASE 版本<!-- Spingboot相关jar包版本 --><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.0.5.RELEASE</version></parent>(2.3)加⼊springboot核⼼包、和web开发必须的包<!-- 相关jar包 --><dependencies><!-- Springboot核⼼jar包 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><!-- web开发包:包含Tomcat和Springmvc --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency></dependencies>(2.4)可以看到,我们项⽬测试类现在还有⼀个⼤红叉,是因为我们刚刚吧把初始的Junit包⼲掉了,现在,我们重新加⼊Junit包。

Hibernate框架简介

Hibernate框架简介

Hibernate框架简介⼀、什么是 Hibernate?Hibernate 是⼀个基于元数据的轻量级的 ORM 框架:1、元数据(Meta Data):data about data(数据的数据),也就是说描述⼀个对象数据,相当于这个对象的上下⽂环境。

2、轻量级:占⽤资源少,没有侵⼊性。

(其实我认为这只是相对⽽⾔,如果和 Ibatis 相⽐,它到成重量级的了)。

3、ORM:(Object Relation Mapping)对象关系数据库的映射这是 Hibernate 框架的重点,也就是说将我们程序中的实体(bean,这⾥也叫 POJO)和数据库中的表进⾏映射。

java 类型和 sql类型映射,⾯向对象设计和关系型数据库设计的映射,从⽽我们只需要将更多的精⼒放到业务中,⽽不是 sql 数据库⽅⾯。

4、POJO:(Plain Ordinary Java Object),⽆格式的普通 java 对象,也就是上边说的实体,和数据库做映射的简单类。

只是在这⾥提出了⼀个新的名词⽽已。

总⽽⾔之,Hibernate 就是将我们的数据库表和程序的 POJO 类进⾏映射,数据的操作进⾏了封装,使我们不⽤把数据库弄得⾮常精通,我们会⾯向对象编程就可以了,这样⼤⼤提⾼了我们的编程效率,⽽且对个⼈的知识要求也降低了。

⼆、Hibernate 基础 ----- 数据库操作在 Hibernate 出现之前,对数据库操作是基于 JDBC,这中间经历了操作 JDBC、封装 JDBC、ORM 三个阶段。

1、操作 JDBC 阶段:本阶段即在调⽤ JDBC 连接数据库的包时,需要⾃⼰进⾏编写的进⾏数据库⽤户登录验证的那段代码。

在这段代码中可以执⾏ SQL 语句进⾏数据查询、插⼊、删除等。

2、封装 JDBC 阶段:由于仅仅只是操作 JDBC,使得在实现不同逻辑功能时,都要重新编写进⾏数据库⽤户登陆验证的那段代码,使得代码重复很严重。

为此,引⼊了 JavaBean的技术,书写⼀个 DBAccess.java 类进⾏数据库⽤户登陆验证和数据库操作,并把其中进⾏数据库操作部分封装成不同的函数,那么实现后续的逻辑功能时只需调⽤这些函数即可实现。

搭建Flex4.1+Spring+Hibernate

搭建Flex4.1+Spring+Hibernate

搭建Flex+Hibernate+Spring环境1.安装MyEclipse8.62.安装FlashBuilder_4_Plugin_LS10.exe3.FlashBuilder安装的过程中需要绑定MyEclipse8.6的路径(绑定的目录下必须有myeclipse.exe文件和dropins文件夹)4.安装成功后,启动MyEclipse8.6,报错"An internal error occurred during: "InitializingTargetCfg"ng.NullPointerException",解决办法是删掉Genuitec\Common\plugins文件夹下面的一个包:mon.http_3.0.3.v201007291200.jar,然后重启MyEclipse8.6。

但是发现不能创建Web工程,所以我就把这个包又加到了plugins文件夹下面。

就没报错了。

(如果MyEclipse8.5中没有Tomcat服务器,就要安装一个Tomcat 插件,方法如下:将com.sysdeo.eclipse.tomcat_3.2.1文件夹放到D:\programfiles\Genuitec\Common\plugins,打开D:\program files\Genuitec\MyEclipse8.5\configuration\org.eclipse.equinox.simpleconfigurator\文件,在最后加上com.sysdeo.eclipse.tomcat,3.2.1,file:/D:/programfiles/Genuitec/Common/plugins/com.sysdeo.eclipse.tomcat_3.2.1/,4,false重启MyEclipse8.5.window --> preferences --> Tomcat 配置一些参数,OK!)5.新建web项目HCS6.添加bleazeds支持找到已解压的bleazeds 文件夹,进入到:blazeds\WEB-INF复制flex和lib两个文件夹到HCS下的webRoot/WEB-INF目录下7.在web.xml文件中添加代码:<!-- Flex配置 --><!-- Http Flex Session attribute and binding listener support --> <listener><listener-class>flex.messaging.HttpFlexSession</listener-class> </listener><!-- MessageBroker Servlet --><servlet><servlet-name>MessageBrokerServlet</servlet-name><!--<display-name>MessageBrokerServlet</display-name>--><servlet-class>flex.messaging.MessageBrokerServlet</servlet-class ><init-param><param-name>services.configuration.file</param-name><param-value>/WEB-INF/flex/services-config.xml</param-value> </init-param><load-on-startup>1</load-on-startup></servlet><servlet-mapping><servlet-name>MessageBrokerServlet</servlet-name><url-pattern>/messagebroker/*</url-pattern></servlet-mapping>8.将web工程添加到tomcat中启动tomcat9.添加Flex工程右键HCS,选择:添加/更改项目类型—>添加Flex项目类型注:服务技术选择如下10.点Next,如下配置11.点击Finish,配置Flex 项目属性在Flex视图下,右键properties打开项目属性设置对话框打开项目属性设置对话框将”生成HTML包装器文件”的钩钩去掉,点击Apply,在将此钩钩钩上点击OK,工程下面就会出现http-template文件夹13,这是http-template文件夹下面的index.template.html文件报错,打开此文件,删除这行注释<!--For version detection,set to min.required Flash Player version, or 0(or 0.0.0),for no version detection.-->保存就没错了13. 到了这个时候基本上已经搭建好Flex+bleazeds的web环境,现在来测试一下1.)新建一个包:er.web2.) 在包中新一个类:HelloWorld,作用flex的一个远程对象,HelloWorld中的代码如下package er.web;public class HelloWorld {public String sayHelloTo(String name){return"Hello "+name;}}3.)在HCS/WebRoot/WEB-INF/flex/remoting-config.xml注册这个远程对象<destination id="Hello"><properties><source>er.web.HelloWorld</source></properties></destination>4.)在src/HCS.mxml 中添加以下代码:<?xml version="1.0" encoding="utf-8"?><mx:Application xmlns:mx="/2006/mxml"layout="absolute"><mx:Script><![CDATA[private functionremotingSayHello(event:Event):void{var iname:String=tiName.text;say.sayHelloTo(iname);}]]></mx:Script><mx:RemoteObject id="say" destination="Hello"></mx:RemoteObject><mx:Button x="335" y="80" label=" Click"click="remotingSayHello(event);"/><mx:TextInput x="159" y="80" id="tiName"/><mx:Label x="109" y="82" text="name:"/><mx:Label text="{stResult}" x="44"y="162" width="448" height="71" id="lblView" color="#FCEE09"fontSize="20" fontWeight="bold" textDecoration="underline"fontStyle="normal"/></mx:Application>5.)启动tomcat,等tomcat启动好后,右键单击HCS.mxml,选中Run As—>Web应用程序,效果如下到了这一步,flex+bleazeds已经完成14.添加Spring框架,在MyEclipse Java Enterprise视图下的步骤如下:点击HCS工程—>MyEclipse—>Add Spring Capabilities点击Next点击Finish点击Keep Existing15. 添加mon,添加SpringFactory.java(网上的)package mon;import org.springframework.context.ApplicationContext;import org.springframework.web.context.support.WebApplicationContextUtils;import org.springframework.beans.BeansException;import org.springframework.beans.factory.NoSuchBeanDefinitionException;import flex.messaging.FactoryInstance;import flex.messaging.FlexFactory;import flex.messaging.config.ConfigMap;import flex.messaging.services.ServiceException;/*** This interface is implemented by factory components which provide* instances to the flex messaging framework. To configure flex data services* to use this factory, add the following lines to your services-config.xml* file (located in the WEB-INF/flex directory of your web application).** &lt;factories&gt;* &lt;factory id="spring" class="flex.samples.factories.SpringFactory" /&gt;* &lt;/factories&gt;** You also must configure the web application to use spring and must copy the spring.jar* file into your WEB-INF/lib directory. To configure your app server to use spring,* you add the following lines to your WEB-INF/web.xml file:** &lt;context-param&gt;* &lt;param-name&gt;contextConfigLocation&lt;/param-name&gt;* &lt;param-value&gt;/WEB-INF/applicationContext.xml&lt;/param-value&gt;* &lt;/context-param&gt;** &lt;listener&gt;*&lt;listener-class&gt;org.springframework.web.context.ContextLoaderListener&lt;/listener-class &gt;* &lt;/listener&gt;** Then you put your spring bean configuration in WEB-INF/applicationContext.xml (as per the * line above). For example:** &lt;?xml version="1.0" encoding="UTF-8"?&gt;* &lt;!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "/dtd/spring-beans.dtd"&gt;** &lt;beans&gt;* &lt;bean name="weatherBean" class="dev.weather.WeatherService" singleton="true"/&gt; * &lt;/beans&gt;** Now you are ready to define a destination in flex that maps to this existing service.* To do this you'd add this to your WEB-INF/flex/remoting-config.xml:** &lt;destination id="WeatherService"&gt;* &lt;properties&gt;* &lt;factory&gt;spring&lt;/factory&gt;* &lt;source&gt;weatherBean&lt;/source&gt;* &lt;/properties&gt;* &lt;/destination&gt;** @author Jeff Vroom*/public class SpringFactory implements FlexFactory{private static final String SOURCE = "source";/*** This method can be used to initialize the factory itself. It is called with configuration * parameters from the factory tag which defines the id of the factory.*/public void initialize(String id, ConfigMap configMap) {}/*** This method is called when we initialize the definition of an instance* which will be looked up by this factory. It should validate that* the properties supplied are valid to define an instance.* Any valid properties used for this configuration must be accessed to* avoid warnings about unused configuration elements. If your factory* is only used for application scoped components, this method can simply* return a factory instance which delegates the creation of the component* to the FactoryInstance's lookup method.*/public FactoryInstance createFactoryInstance(String id, ConfigMap properties){SpringFactoryInstance instance = new SpringFactoryInstance(this, id, properties);instance.setSource(properties.getPropertyAsString(SOURCE, instance.getId()));return instance;} // end method createFactoryInstance()/*** Returns the instance specified by the source* and properties arguments. For the factory, this may mean* constructing a new instance, optionally registering it in some other* name space such as the session or JNDI, and then returning it* or it may mean creating a new instance and returning it.* This method is called for each request to operate on the* given item by the system so it should be relatively efficient.* <p>* If your factory does not support the scope property, it* report an error if scope is supplied in the properties* for this instance.*/public Object lookup(FactoryInstance inst){SpringFactoryInstance factoryInstance = (SpringFactoryInstance) inst;return factoryInstance.lookup();}static class SpringFactoryInstance extends FactoryInstance{SpringFactoryInstance(SpringFactory factory, String id, ConfigMap properties){super(factory, id, properties);}public String toString(){return "SpringFactory instance for id=" + getId() + " source=" + getSource() + " scope=" + getScope();}public Object lookup(){ApplicationContext appContext = WebApplicationContextUtils.getWebApplicationContext(flex.messaging.FlexContext.getServletC onfig().getServletContext());String beanName = getSource();try{return appContext.getBean(beanName);}catch (NoSuchBeanDefinitionException nexc){ServiceException e = new ServiceException();String msg = "Spring service named '" + beanName + "' does not exist.";e.setMessage(msg);e.setRootCause(nexc);e.setDetails(msg);e.setCode("Server.Processing");throw e;}catch (BeansException bexc){ServiceException e = new ServiceException();String msg = "Unable to create Spring service named '" + beanName + "' ";e.setMessage(msg);e.setRootCause(bexc);e.setDetails(msg);e.setCode("Server.Processing");throw e;}}}}16. 在WEB-INF/flex中的services-config.xml中注册SpringFactory工厂<factories><factory id="spring"class="mon.SpringFactory"/></factories>17.在WEB-INF文件夹下建立conf文件夹,将applicationContext.xml 移入此中,在WEB-INF/web.xml中加入对spring的支持<!-- Spring配置 --><!-- Backend configuration --><context-param><param-name>contextConfigLocation</param-name><param-value>/WEB-INF/conf/*/spring-*.xml,/WEB-INF/conf/applicationContext.xml</param-value></context-param><servlet><servlet-name>SpringContextServlet</servlet-name><servlet-class>org.springframework.web.context.ContextLoaderServlet </servlet-class><load-on-startup>1</load-on-startup></servlet><servlet><servlet-name>SpringLog4jConfigServlet</servlet-name> <servlet-class>org.springframework.web.util.Log4jConfigServlet </servlet-class></servlet><servlet><servlet-name>web</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet </servlet-class></servlet>17.添加hibernate1).创建表create table hcs_user(user_id int primary key not null,user_name varchar2(30),real_name varchar2(20),password varchar2(20),sex varchar2(3),birthday varchar2(30),email varchar2(40),address varchar2(50),telephone varchar2(20),qq varchar2(15),authority varchar2(50),remarks varchar2(50));2).切换到MyEclipse Hibernate视图添加数据源New Database Connection Dirver点击Next,点击Finish3.)加进hibernate框架,在MyEclipse Java Enterprise视图下的步骤如下:点击HCS工程—>MyEclipse—>Add Hibernate Capabilities18.添加包,结构如下:19.删除asm-2.2.3.jar20.利用myeclipse自动生成User.java,User.hbm.xml,UserDAO右击表名,选中Hibernate Reverse Engineering,21.把UserDAO放到er.dao.impl下22.修改applicationContext.xml<bean id="userDAO"class="erDAO"> <property name="sessionFactory"><ref bean="sessionFactory"/></property></bean>23.在er.service.impl添加service类,起名IUserServiceImplpackage er.service.impl;import erDAO;import er;public class IUserServiceImpl {private UserDAO userDAO;public void setUserDAO(UserDAO userDAO) {erDAO = userDAO;}/*通过ID搜索返回一个User对象* @param id 需要查找的用户ID* @return User对象**/public User getUser(java.math.BigDecimal id){return userDAO.findById(id);}}24. 修改HellWorld.java文件package er.web;import java.math.BigDecimal;import er;import er.service.impl.IUserServiceImpl;public class HelloWorld {private IUserServiceImpl userService;/** 该方法通过用户ID返回用户名* @param id 用记ID* @return String “你好”+用户名*/public String sayHelloTo(String id){User user = new User();user = userService.getUser(BigDecimal.valueOf(Long.parseLong(id)));return "Hello "+user.getUserName();}public void setUserService(IUserServiceImpl userService) { erService = userService;}}25.在WEB-INF的conf文件夹下面添加如下文件dbconfig.properties文件通过配置文件设置访问Oracle数据库的参数代码如下#Database Settings#db urlDATABASE_URL=localhost#db nameDATABASE_NAME=xe#db login user nameDATABASE_USERNAME=HCS#db login user passwordDATABASE_PASSWORD=123#db portDATABASE_PORT=1520driverClassName=oracle.jdbc.driver.OracleDriverlog4j.properties文件日志输出代码如下:#log4j.rootLogger=INFO,A1,R#log4j.rootLogger=DEBUG,A1,Rlog4j.rootLogger=DEBUG,A1log4j.appender.A1=org.apache.log4j.ConsoleAppenderyout=org.apache.log4j.PatternLayoutyout.ConversionPattern=%-d{yyyy-MM-ddHH:mm:ss,SSS}[%c]-[%p]%m%nlog4j.appender.R=org.apache.log4j.RollingFileAppenderlog4j.appender.R.File=D:/SSH.txtlog4j.appender.R.MaxFileSize=5120KBlog4j.appender.R.MaxBackupIndex=1yout=org.apache.log4j.PatternLayoutyout.ConversionPattern=%d{yyyy-MM-ddHH\:mm\:ss,SSS}[%t][%c][%p]-%m%n在web.xml文件中添加<!--log4j config start!--><context-param><param-name>log4jConfigLocation</param-name><param-value>/WEB-INF/conf/log4j.properties</param-value> </context-param><context-param><param-name>log4jRefreshInterval</param-name><param-value>60000</param-value></context-param><listener><listener-class>org.springframework.web.util.Log4jConfigListener </listener-class></listener><!--log4j end .-->日志输出添加user文件夹里面添加如下文件spring-dao.xml代码如下:<?xml version="1.0"encoding="UTF-8"?><beansxmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:p="/schema/p"xsi:schemaLocation="/schema/b eans/schema/beans/spring-beans-2.5.xsd"><bean id="userDAO"class="erDAO"><property name="sessionFactory"><ref bean="sessionFactory"/></property></bean></beans>spring-service.xml代码如下:<?xml version="1.0"encoding="UTF-8"?><beansxmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:p="/schema/p"xsi:schemaLocation="/schema/b eans/schema/beans/spring-beans-2.5.xsd"><bean id="userService"class="er.service.impl.IUserServiceImpl"> <property name="userDAO"><ref bean="userDAO"/></property></bean></beans>spring-web文件代码如下:<?xml version="1.0"encoding="UTF-8"?><beansxmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:p="/schema/p"xsi:schemaLocation="/schema/b eans/schema/beans/spring-beans-2.5.xsd"><bean id="helloWorld"class="er.web.HelloWorld"><property name="userService"><ref bean="userService"/></property></bean></beans>26.修改applicationContext.xml代码如下:<?xml version="1.0"encoding="UTF-8"?><beansxmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:p="/schema/p"xsi:schemaLocation="/schema/b eans/schema/beans/spring-beans-2.0.x sd"><bean id="propertyConfigurer"class="org.springframework.beans.factory.config.PropertyPla ceholderConfigurer"><property name="locations"><list><value>/WEB-INF/conf/dbconfig.properties</value> </list></property></bean><!-- 配置数据源 --><bean id="dataSource"class="mons.dbcp.BasicDataSource"><!-- 驱动类 --><property name="driverClassName"><value>${driverClassName}</value></property><!-- 数据库连接地址 --><property name="url"><value>jdbc:oracle:thin:@${DATABASE_URL}:${DATABASE_PORT}:$ {DATABASE_NAME}</value></property><property name="username"><value>${DATABASE_USERNAME}</value></property><property name="password"><value>${DATABASE_PASSWORD}</value></property></bean><!-- hibernate Session工厂 --><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFacto ryBean"><property name="dataSource"><ref bean="dataSource"/></property><!-- 下面是hibernate的属性设置 --><property name="hibernateProperties"><props><prop key="hibernate.dialect">org.hibernate.dialect.Oracle9Dialect</prop><prop key="hibernate.query.factory_class">org.hibernate.hql.classic.ClassicQueryTranslatorFactory</prop><prop key="hibernate.autoReconnect">true</prop><!-- 显示输出SQL --><prop key="hibernate.show_sql">true</prop><!-- 输入SQL时进行格式化 --><prop key="hibernate.format_sql">true</prop></props></property><property name="mappingResources"><list><value>com/zuohd/hcs/user/model/User.hbm.xml</value></list></property></bean></beans>27.修改:WEB-INF/flex/remoting-config.xml<destination id="Hello"><properties><factory>spring</factory><source>helloWorld</source></properties></destination>28.启动tomcat,运行页面,效果:。

Hibernate学习总结

Hibernate学习总结

一.对象语言和操作数据库不匹配:模型不匹配(阻抗不匹配)①.可以使用JDBC手动转换;sql参数和jdbc中用对象赋值②.使用ORM(Object Relation Mapping对象关系映射)框架:hibernate 二.Hibernate安装配置①.配置文件Hibernate.cfg.xml和Hibernate.properties②.映射文件xxx.hbm.xml:对象模型和关系模型的映射三.开发流程1.由Domain Object -> mapping -> db2.有DB开始,用工具生成mapping和Domain Object3.由配置文件开始四.Domain Object限制1.默认的构造方法(必须的)2.有无意义的标示符id(主键) 可选3.非final的,对懒加载有影响可选Configuration SessionFactory Session Transaction Query CriteriaConfiguration类Configuration类负责配置并启动Hibernate,创建SessionFactory对象。

在Hibernate的启动的过程中,Configuration类的实例首先定位映射文档位置、读取配置,然后创建SessionFactory 对象。

SessionFactory接口SessionFactory接口负责初始化Hibernate。

它充当数据存储源的代理,并负责创建Session对象。

这里用到了工厂模式。

需要注意的是SessionFactory并不是轻量级的,因为一般情况下,一个项目通常只需要一个SessionFactory就够,当需要操作多个数据库时,可以为每个数据库指定一个SessionFactory。

Session接口Session接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流,包含了很多常见的SQL语句。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

创建hibernate项目步骤:
(1)new -- javaproject--输入项目名称(与web没有关系,只与jdbc有关系的)
(2)添加数据库。

首先显示,windows--show views--other--
选择DB Browser
(3)可以看到显示,右键空白处
(4)可以看到显示,右键空白处new 如果是mysql:选择MYSQL Connector/J
如果是oracle:选择Oracle(Thin driver)
(5)弹出classname,点击finish。

可以看到已经完成。

(6)右键数据库,选择对应的库,表,右键--Hibernate reverse engineering--
(7)选择包,选择对应的选项--next
(8)选择native--next
entity包下创建Car类,然后选择native--点击finish。

字:dosql.sql文件。

(11)创建sql文件后,输入语句:select * from emp;在sql results中可以查看。

在自动生成emp实体类,自动生成的 Emp.hbm.xml 。

这些是根据数据库生成的java代码和配置文件。

接着来写测试类
在自动生成emp类中 sourse--new一个toString方法。

(12)创建HibernateTest类。

import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import entity.Emp;
public class HibernateTest {
public static void main(String[] args) {
//Hibernate的配置类对象,用于创建SessionFactory.
Configuration conf = new Configuration().configure();
//会话(session)工厂, 用于创建Session的. 等价于jdbc的Connection
SessionFactory factory = conf.buildSessionFactory();
//开启会话
Session session = factory.openSession();
//通过会话 curd操作.
//保存一个对象,通过测试
saveEmpTest(session);
//修改对象,通过测试
//updateEmpTest(session);
//删除一个,通过测试
//removeEmpTest(session);
//查询一个对象,通过测试
queryEmpById(session, 7900);
//查询列表
queryEmpList(session);
queryEmpListByDeptno(session, 10);
//会话完毕之后要关闭
session.close();
//关闭工厂
factory.close();
}
static void saveEmpTest(Session session){
Emp emp = new Emp();
emp.setEmpno(1); //由于hbm重配置的主键生成策略是native, 所以指定的工号无效..
emp.setEname("新建的名字");
session.beginTransaction(); //开启事务
session.save(emp);
session.getTransaction().commit();//提交事务
}
static void updateEmpTest(Session session){
/*Emp emp = new Emp();
emp.setEmpno(1);
//emp.setEname("DEF");
emp.setSal(1000.0);
session.update(emp);*/
//先查出对象(持久化状态的).
Emp emp = (Emp)session.get(entity.Emp.class, 7938);//类名,后边参数是写编号,修改名字。

//修改对象属性
emp.setEname("Sam");
session.beginTransaction(); //开启事务
session.getTransaction().commit();//提交事务
}
//删除表格,成功删除
static void removeEmpTest(Session session){
Emp emp = new Emp();
emp.setEmpno(7938);
session.delete(emp);
session.beginTransaction(); //开启事务
session.getTransaction().commit();//提交事务
}
static void queryEmpById(Session session , Integer empno){ Emp emp = null;
emp = (Emp)session.get(entity.Emp.class, empno);
//emp = (Emp)session.load(entity.Emp.class, empno);
//---get / load 有区别
System.out.println(emp);
}
//HQL查询
static void queryEmpList(Session session){
Query query = session.createQuery("from Emp");
List<Emp> empList = query.list();
System.out.println(empList);
}
static void queryEmpListByDeptno(Session session, Integer deptno){
Query query = session.createQuery("from Emp where deptno = :deptno");
query.setParameter("deptno", deptno);
List<Emp> empList = query.list();
System.out.println(empList);
}
}
(13)运行程序,可以看到下边打印出数据库的信息。

(14)一个简单的hibernate程序创建成功了,接着就可以
写程序啦。

错误提示:原因是服务器没开。

相关文档
最新文档