Hibernate+Spring+Struts2+ExtJS开发CRUD功能

Struts的原理和优点.Struts工作原理MVC即Model—View—Controller的缩写，是一种常用的设计模式。

MVC 减弱了业务逻辑接口和数据接口之间的耦合，以及让视图层更富于变化。

MVC的工作原理，如下图1所示：Struts 是MVC的一种实现，它将Servlet和JSP 标记(属于J2EE 规范）用作实现的一部分。

Struts继承了MVC的各项特性,并根据J2EE的特点，做了相应的变化与扩展.Struts的工作原理，视图:主要由JSP生成页面完成视图，Struts提供丰富的JSP 标签库: Html，Bean，Logic，Template等，这有利于分开表现逻辑和程序逻辑。

控制：在Struts中,承担MVC中Controller角色的是一个Servlet，叫ActionServlet。

ActionServlet是一个通用的控制组件。

这个控制组件提供了处理所有发送到Struts的HTTP请求的入口点。

它截取和分发这些请求到相应的动作类(这些动作类都是Action类的子类）。

另外控制组件也负责用相应的请求参数填充Action From（通常称之为FromBean），并传给动作类（通常称之为ActionBean）。

动作类实现核心商业逻辑，它可以访问java bean 或调用EJB。

最后动作类把控制权传给后续的JSP 文件，后者生成视图。

所有这些控制逻辑利用Struts-config.xml文件来配置。

模型：模型以一个或多个java bean的形式存在。

这些bean分为三类：Action Form、Action、JavaBean or EJB.Action Form通常称之为FormBean，封装了来自于Client的用户请求信息,如表单信息。

Action通常称之为ActionBean，获取从ActionSevlet传来的FormBean,取出FormBean中的相关信息，并做出相关的处理，一般是调用Java Bean或EJB等。

java开发简历crud怎么编写技术要点Java开发简历CRUD是指在Java开发中，完成对数据库进行增删改查操作（Create，Retrieve，Update，Delete）。

在编写相关技术要点时，可以包括以下内容：1. 数据库基础知识：了解常见数据库的基本概念和操作，如MySQL、Oracle等。

掌握SQL语句的编写，熟悉常见的SQL 操作，如增删改查等。

2. Java编程基础：具备扎实的Java语言基础知识，包括面向对象思想、基本语法、流程控制、异常处理等。

掌握Java核心类库，熟悉常用的集合类和IO操作等。

3. JDBC技术：了解JDBC的基本原理和使用方法。

掌握数据库连接的建立、SQL语句的执行以及结果集的处理等。

熟悉JDBC的基本接口和常用类，如Connection、Statement、PreparedStatement等。

4. ORM框架：了解常见的ORM框架，如Hibernate、MyBatis 等。

熟悉ORM框架的配置和使用方法，掌握实体类与数据库表之间的映射关系的配置。

了解ORM框架的优缺点，能够根据需求选择合适的框架。

5. 设计模式：了解常见的设计模式，如单例模式、工厂模式、观察者模式等。

在实际开发中，合理运用设计模式能够提高代码的可维护性和扩展性。

6. Web开发技术：对于基于Web的Java开发，掌握常见的Web开发技术。

熟悉HTTP协议和Servlet规范，了解常见的Web容器，如Tomcat等。

熟悉JSP和前端技术，如HTML、CSS、JavaScript等。

7. Spring框架：熟悉Spring框架的基本原理和使用方法。

了解Spring的核心功能，如IoC和AOP等。

掌握Spring的常见模块，如Spring MVC、Spring Boot等。

了解Spring与其他框架的整合，如Spring和Hibernate的整合等。

8. 测试与调试：了解常用的测试框架和调试工具。

java开发简历crud怎么编写技术要点Java开发简历CRUD（Create, Read, Update, Delete）是指对数据库的基本操作，包括新增数据、查询数据、更新数据和删除数据。

在编写Java开发简历时，需要突出自己在CRUD方面的技术要点，以展示自己在Java开发方面的能力和经验。

以下是一些可能包含在Java 开发简历CRUD技术要点中的内容。

1.数据库知识：说明自己熟悉常见的关系型数据库（如MySQL、Oracle等）以及非关系型数据库（如MongoDB、Redis等），了解数据库的基本概念和原理，能够使用SQL语言编写查询语句、创建表、定义索引等。

2. Java编程语言：突出自己熟练掌握Java语言，包括面向对象编程（OOP）的基本理念和特性，熟悉Java的核心类库和常用的开发框架。

3. JDBC（Java Database Connectivity）：说明自己熟悉JDBC编程，能够使用JDBC API连接数据库，执行SQL语句，处理结果集等。

还可以介绍自己对JDBC的一些高级特性的了解，如批量处理、事务管理等。

4. ORM（Object-Relational Mapping）框架：如果有使用过ORM 框架（如Hibernate、MyBatis等）的经验，可以突出说明。

说明自己能够使用ORM框架实现数据对象（DO）与数据库表之间的映射，简化数据库操作的开发流程。

5. SQL优化：突出自己对SQL优化的经验和技巧。

说明自己能够分析查询语句的执行计划，使用索引加速查询，优化SQL语句的逻辑和物理结构，提升数据库的性能。

6.事务管理：说明自己熟悉事务的概念和原理，能够使用数据库事务来确保数据的一致性和完整性。

还可以介绍自己对分布式事务（如XA事务）的了解和使用经验。

7.缓存技术：说明自己熟悉常见的缓存技术（如Redis、Memcached等），能够将缓存技术应用于减轻数据库的压力，提高系统的性能和可伸缩性。

Struts2+Hibernate3.2+Sprint2.5整合Hibernate使用数据库连接池、MyEclipse6.5Tomcat6.0创建项目，整合Hibernate右键项目，MyEclipse—>Add Hibernate Capabilities使用Spring管理，把勾去掉整合Spring2.5右键项目，MyEclipse—>AddSpring Capabilities配置Hibernate的数据源Hibernate自带的连接池算法相当不成熟。

它只是为了让你快些上手，并不适合用于产品系统或性能测试中。

出于最佳性能和稳定性考虑你应该使用第三方的连接池。

只需要用特定连接池的设置替换hibernate.connection.pool_size 即可。

这将关闭Hibernate自带的连接池。

例如，你可能会想用C3P0.C3P0是一个随Hibernate一同分发的开源的JDBC连接池，它位于lib目录下。

如果你设置了hibernate.c3p0.*相关的属性，Hibernate将使用C3P0ConnectionProvider来缓存JDBC连接。

如果你更原意使用Proxool，请参考发行包中的hibernate.properties并到Hibernate网站获取更多的信息。

<?xml version="1.0"encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:jee="/schema/jee"xsi:schemaLocation="/schema/beans[url]/schema/beans/spring-beans-2.0.xsd[/url] [url]/schema/jee[/url][url]/schema/jee/spring-jee-2.0.xsd[/url]"><!--********************配置数据源，采用C3P0********************--> <bean id="dataSource"class="boPooledDataSource"destroy-method="close"><property name="driverClass"><value>com.microsoft.sqlserver.jdbc.SQLServerDriver</value> </property><property name="jdbcUrl"><value>jdbc:sqlserver://localhost:1433;DatabaseName=shopping</value> </property><property name="user"><value>sa</value></property><property name="password"><value>sa</value></property><!--连接池中保留的最小连接数。

Java语言应用中的常见技术和框架介绍Java语言是一门广泛应用的高级编程语言，自推出以来就一直受到程序员们的青睐。

由于其平台无关性、可移植性以及强大的生态系统，Java语言在大型企业级应用开发、云计算、数据科学、Web开发等领域得到广泛应用。

在Java语言技术的基础上，还有很多重要的技术和框架，下面就来简单介绍一下Java常见的技术和框架。

一、Spring框架Spring是目前最流行的开源Java框架之一，它提供了一个全面的编程和配置模型，可以解决开发企业级应用中遇到的各种问题。

Spring框架提供了一个轻量级的容器，其中可以管理对象的生命周期，控制依赖注入和AOP（面向切面编程）等关键特性。

此外，Spring还提供了一系列的插件和扩展，用于支持持久化、web开发、缓存、安全、集成和测试等方面的功能。

二、Hibernate框架Hibernate是一个流行的ORM（对象关系映射）框架，它是Java持久化的事实标准。

Hibernate的主要目标是简化数据访问并提高开发人员的生产力，它通过在代码中使用对象来处理数据库中的数据，将对象映射到关系数据库中的表和列。

Hibernate提供了一系列的API和工具，支持查询、缓存、事务管理和数据库连接池等特性。

Hibernate还支持多种关系型数据库，包括MySQL、Oracle和SQL Server等。

三、Struts框架Struts是一个流行的MVC（模型-视图-控制器）框架，它可以帮助开发人员组织和管理Web应用程序。

Struts的核心组件是Action，它处理来自浏览器的请求并根据请求内容执行相应的动作。

Struts还提供了一些其他的功能，包括表单数据验证、错误处理、邮件和文件上传等。

Struts具有很高的可扩展性，可以与其他框架和工具一起使用。

四、Java EEJava EE（Java Enterprise Edition）是一个广泛使用的Java应用程序平台，这个平台包含了许多基本的技术和API，用于构建企业级应用。

这篇文章本来是要在昨天睡觉之前发上来，但是家里的网速实在是让我郁闷，刚忙完工作偷空上来赶紧发了，还有一点让我郁闷的就是JavaEye的这个编辑器不是太好用，在word里面写好的内容不能全部粘贴过来，文档中有很多图片，需要一张张上传，然后在加上来！痛苦。

以后还是少截图。

不说了，还是赶紧发文章吧！1、数据库设计建立crud.student数据库表：图1 数据库表你可以使用如下语句创建该库表：Sql代码1.create database if not exists `crud`;E `crud`;3.DROP TABLE IF EXISTS `student`;4.CREATE TABLE `student` (5. `id` int(4) NOT NULL auto_increment,6. `name` varchar(20) default NULL,7. `age` int(4) default NULL,8. `score` int(4) default NULL,9. PRIMARY KEY (`id`)10.) ENGINE=InnoDB DEFAULT CHARSET=utf8;在这里我使用的是SQL Server2000数据库，当然你也可以选择别的数据库，只是在选择之前请准备好相应的jar包即可。

2、程序编写：第一步：配置数据源1、打开MyEclipse，新建一个web工程，这里命名为hibernate_demo2、打开数据库设置器：依次单击【window】-->【Show View】-->【Other…】如下图所示：3、在弹出的窗口ShowView中选择DB Browser,如下图所示:4、在DB Browser窗口中，选择显示的图标，单击右键执行新建命令，如下图示5、弹出Database Driver对话框，在此会要求我们配置数据库的相关信息，具体设置如下图所示，设置完成，单击Finish.(Connection URL填写：jdbc:microsoft:sqlserver://localhost:1433 Driver IARS：加入SQL Server 的那三个jar包)【第二步】引入hibernate配置文件1、添加hibernate包：选中我们的Web工程，依次单击鼠标右键-->MyEclipse-->Add Hibernate Capabilities… 如下图所示：2、在弹出的窗口中做如下设置：【Next】【Next】单击Next，把要创建的SessionFactory放置于相应的包中，如果前面没有设置包名，这里要先单击New创建新的包。

一、本课程是怎么样的一门课程（全面介绍）1.1、课程的背景该课程是北风品牌课程-《BF-TECH J2EE软件工程师就业课程》第四阶段：课程二、Struts2+Spring3+Hibernate4+ExtJS4.2开发企业富客户端商业应用课程。

由于富客户端技术进一步扩展浏览器功能,使之提供更加高效和友好的用户接口，越来越多的企业和开发人员选择使用富客户端技术构建商业应用1.2、课程内容简介本课程主要是介绍ExtJs4.0 最新版本特性，了解并掌握extjs4语法及应用，了解最流行的富客户端框架及熟悉掌握其高级特性，并结合SSH框架与DWR实现富户端商业应用的全部开发过程1.3、课程大纲一、理论讲解部分：ch01_ExtJS4快速入门-Hello ExtJs4第一讲：ExtJS4.x框架最新特性简介第二讲：第一个ExtJS4.x官方推荐示例程序第三讲：利用sencha sdk tool打包发布ExtJS4.x应用ch02_ExtJs 4 新类库特性及JS新语法扩展第一讲：ExtJS4 对JS语法的扩展第二讲：ExtJS 4 中的新功能- 定时事件与健盘导航第三讲：ExtJS 4 类库新特性-Ext.difine与Configurationch03_ExtJs 4 中布局与容器第一讲：ExtJs 4 类的混合与静态类的使用第二讲：ExtJs 4 中的容器与布局(上）第三讲：ExtJs 4 中的容器与布局(下）ch04_ExtJs 4 常用组件详解第一讲：Ext.Button组件详解第二讲：Ext.MessageBox组件详解第四讲：滚轴控件、进度条控件和编辑控件第五讲：Ext中面板与VIewport组件第六讲：Ext.tab.tabPanel组件详解ch05_ExtJs 4 选择器与DOM操作第一讲：Ext.DomQuery中的选择器第二讲：Ext4中利用DomQuery进行筛选与过滤第三讲：Ext4中的DOM操作与事件ch06_ExtJs 4 中的数据操作(Proxy+Model+Store)第一讲：Ext.Ajax.Request功能详解第二讲：Ext.data.Proxy Rest及Direct操作数据第三讲：Ext.data.Model及自定义验证详解第四讲：Ext.data.Store对数据的操作第五讲：Store+Model+Proxy综合示例ch07、ExtJs 4 中的Form表单详解第一讲：BasicForm+BaseField的配置项、属性、方法和事件第二讲：常用的验证函数Ext.form.field.VTypes第三讲：常用Form表单组件详解（一）第四讲：常用Form表单组件详解（二）第五讲：常用Form表单组件详解（三）第六讲：常用Form表单组件详解（四）第七讲：Form表单的加载、提交与验证数据第八讲：综合示例-产品信息管理ch08、ExtJs 4 中的复杂组件-Grid && Tree第一讲：Ext4 Grid组件配置详解第二讲：Grid的本地排序和过滤第三讲：Grid行内数据修改及主从表实现第四讲：Tree的配置项、属性、方法和事件第五讲：Tree 的动态加载与维护ch09、ExtJs 4 中的图形与图表第一讲：ExtJs中的图表初探第二讲：ExtJs中的图表详解第三讲：ExtJs中的图表高级第五讲：ExtJs中的图形高级ch10_ExtJs 4 中的MVC应用架构第一讲：ExtJS 4 MVC原理第二讲：ExtJS 4.x MVC框架搭建与注意事项第三讲：ExtJS 4.x MVC综合示例（一）第四讲：ExtJS 4.x MVC综合示例（二）ch11_SSH2 整合ExtJs 4 MVC开发Web应用第一讲：本章简介、后台框架简介、登录功能第二讲：前台框架搭建，构造出菜单树第三讲：用户的初步界面，完成查询功能、添加功能第四讲：用户的修改、删除功能和导入eclipse中需要注意的事项ch12_ExtJs4.2 中主题与皮肤第一讲：ExtJs4.2 中主题与皮肤快速制作（一）第二讲：ExtJs4.2 中主题与皮肤快速制作（二）第三讲：ExtJs4.2 中主题与皮肤按标准制作（一）第四讲：ExtJs4.2 中主题与皮肤按标准制作（二）更多免费资料视频加群106537671二、项目讲解部分(讲师：飞扬)：第1章：项目基本框架搭建、Extjs4的MVC中添加多个Controller支持第2章：菜单树配置、动态获取菜单树、展示用户列表第3章：后台框架简单封装，角色管理初步讲解第4章：角色管理、展示权限树第5章：角色管理，通过权限树动态修改角色权限第6章：部门管理，树形结构的动态添加、移除第7章：部门管理，树形结构的顺序调整第8章：项目管理，新建工作项目第9章：普通下拉列表，树形下拉列表，多选下拉列表的实现第10章：实现多选下拉列表如何修改，用户登录后根据角色构造权限树。

SpringMVC实现⼀次简单的CRUD⽰例基本环境搭建1、数据库和实体类的名字相同，实体类属性名即数据库字段名。

2、创建实体类对应 dao 类，持久层框架 mybatis 正处于学习中，这⾥就⽤原始的 jdbc 操作了。

3、创建⼀个 java 类，作为 Controller，处理请求。

4、CRUD 涉及到显⽰数据、修改、添加的页⾯；删除就不需要了，修改和添加使⽤同⼀个页⾯。

所以就有 index.jsp(⼀个超链接跳转到 show.jsp)、show.jsp(显⽰所有员⼯信息和操作链接)、input.jsp(⽤于修改和添加)。

具体实现接下来就是 CRUD 的具体实现了，顺序为查询显⽰所有员⼯信息-->删除-->添加-->修改。

在具体的实现前，需要了解⼀下 Controller 类的⼤致结构：package com.taohan.controller;//import *;@Controller@SuppressWarnings("all")public class CURD {@Autowiredprivate DepartmentInfoDao departDao;@Autowiredprivate EmployeeInfoDao empDao;//在后⾯的具体描述中，就只贴出处理对应请求的⽅法代码了}查询①在 index.jsp 页⾯中加⼊下⾯超链接，⽤于获取到所有员⼯集合，保存到域对象中，最后转发(内部跳转) 到 show.jsp 进⾏显⽰。

<a href="emps" rel="external nofollow" >员⼯信息</a>②该请求会交由 Controller 中的指定⽅法处理，下⾯就需要定义处理该请求的⽅法。

//获取所有的员⼯信息@RequestMapping("/emps")public String getemps(Map<String, Object> map) {//获取员⼯集合，存⼊ map 集合中map.put("emps", empDao.getEmployees());return "show";}③现在已经获取到了员⼯集合了，接下来就是编写 show.jsp 页⾯了。

struts2+spring+hibernate三大框架环境搭建小小总结：一、环境搭建导入各种jar包什么的就不多说了。

二、整个包结构及模式：1、src文件下，由panyname组成一个大的包结构和各项配置文件组成2、companyname下，分成两部分：A、model层B、功能层3、model层下，包含整个项目所要的数据库表名，按照功能来命名包的名称，A、功能包下包含对应的数据库表的java类，里面包含对应数据库表中所有的字段以及get，set方法B、功能包下包含对应的数据库表的hbm.xml类，里面包含对应数据库表中所有字段的定义4、功能层下，可以只有一个功能模块的一个结构，也可以有多个功能模块的包结构，再在包结构下细分到功能模块的结构A、一个完整的功能模块包下包含：action，dao，service层，1>、对应的action层包含对应功能实现的Action类；2>、对应的dao层包含对应功能实现的数据库操作类；3>、对应的service层包含对应功能实现的各service接口；5、各项配置文件：A、首先包含三个大的配置文件：applicationContext.xml，struts.xml，jdbc.propertiesB、applicationContext.xml实现依赖注入，struts.xml实现各响应功能的配置，jdbc.properties配置数据库相关属性三、页面1、所有的页面，js包都放到WebRoot目录下，2、要配置web.xml文件3、所有的jar包放到WebRoot-WEB-INF-lib包下四、功能操作1、定义好model层，配置好对应的model.hbm.xml映射文件2、将对应的model.hbm.xml映射文件映射到applicationContext.xml文件中3、页面中对应的跳转，实现action，到struts-function.xml去增加对应的Action类和方法4、将struts-function.xml映射文件映射到struts.xml映射文件中5、在功能层下建立对应的功能包，包下包含action，dao，service三个层6、根据struts-function.xml映射文件，建立对应的Action类，在类中创建对应的方法7、在service层和dao层下分别建立对应的接口层和实现接口类8、在对应的applicationContext-function.xml映射文件中将dao层方法映射到对应的service 层中9、service层中，包含iservice层和实现iservice层的service10、在service类中实现对应的iservice定义的方法，并return这个dao对象的方法，11、根据这个方法，在idao接口中创建对应的方法，在dao层的实现类中来具体实现方法的业务12、dao层实现之后，将在Action中调用对应的dao层实现的方法，然后保存结果返回到对应的界面去13、至此，简单的一个业务就实现了。

·在实现CRUD之前，我想你的开发环境已经搭建好了，我们就不作搭建的说明了，直接进入正题；一般搭建环境都是项目经理的事情，项目经理搭建完环境，就会把环境放到svn服务器上，你只需要从服务器上检出项目环境开发即可；File→Inport→SVN→从SVN检出项目我的资源库已经创建好了，你从视图中打开资源库视图创建一个资源库就好了，选择项目文件夹finish即可；·我们首先要生成简单Java类，也称POJO类，既然有添加hibernate的开发支持，当然要用hibernate提供的功能了,那我们首先编写一个数据库创建脚本，其中包括最常用的字段即可，就编写一个雇员表吧；USE mysql ;DROP TABLE emp ;CREATE TABLE emp(empno INT AUTO_INCREMENT ,ename VARCHAR(30) NOT NULL ,hiredate DATE ,sal VARCHAR(50) NOT NULL ,CONSTRAINT pk_nid PRIMARY KEY(empno)) ;·用hibernate生成一个表的对应的简单java类，打开DB Browser视图→找到对应的表右键→hibernate Reverse Engineering……这个界面就按照下图的设置，下图中没显示的部分，取消勾选，不做设置；·配置完成之后，会生成一个以表名称为类名的一个简单java类，不过首字母大写，采用的annotation注解的方式和数据表配置了映射关系，生成的类会有一些警告，压制一些就OK了，生成的构造方法没有任何用处，删掉即可，一些注释也可以删掉了，另外增加一个toString()方法，这样在做一些异常调试的时候很方便，此类我做了一点简单的注释，可以一看；Emp.javapackage cn.oracle.pojo;import java.util.Date;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Id;import javax.persistence.Table;import javax.persistence.Temporal;import javax.persistence.TemporalType;@SuppressWarnings("serial")→压制警告用的@Entity→代表这一个实体，与数据表映射对应；@Table(name = "emp", catalog = "mysql")→此设置了这个实体对应的数据库名称和表名称；name 属性是表名称，catalog 是你用到数据库的名字；public class Emp implements java.io.Serializable {private Integer empno;→对应的字段名称；private String ename; →对应的字段名称；private Date hiredate; →对应的字段名称；private String sal; →对应的字段名称；@Id→表示这个字段值主键，唯一的@GeneratedValue→表示此字段自动增长，@Column(name = "empno", unique = true, nullable = false)→对应表中的列的属性，name 表示列名称，unique表示唯一性,nullable表示是否为空；public Integer getEmpno() {return this.empno;}public void setEmpno(Integer empno) {this.empno = empno;}@Column(name = "ename", nullable = false, length = 30)→length表示长度public String getEname() {return this.ename;}public void setEname(String ename) {this.ename = ename;}@Temporal(TemporalType.DATE)→专门标注日期的；@Column(name = "hiredate", length = 10)public Date getHiredate() {return this.hiredate;}public void setHiredate(Date hiredate) {this.hiredate = hiredate;}@Column(name = "sal", nullable = false, length = 50)public String getSal() {return this.sal;}public void setSal(String sal) {this.sal = sal;}@Overridepublic String toString() {return"Emp [empno=" + empno + ", ename=" + ename + ", hiredate="+ hiredate + ", sal=" + sal + "]";}}·简单java类完成是第一步，然后我们需要配置数据库连接了，这是正常的思维模式，也就是最基本的JDBC开发思维模式，但是这一步spring已经在配置的时候已经交给了spring管理了数据库的连接池，只要得到对应的bean就可以得到数据库连接了，也就能操作数据库了；数据库连接类也就相当于spring给我们提供好了，那接下来就是编写接口了，首先编写DAO层接口，DAO(data access Object) 叫做数据访问对象，首先，我们利用泛型编写一个公共的DAO接口，实现基本的CRUD ，当数据表非常多的时候编写此公共的接口很节省代码的；IDAO.javapackage cn.oracle.dao;import java.util.List;public interface IDAO<K,V> {/*** 增加一条数据；* @param vo 简单Java类对象；* @return返回一个boolean对象，增加成功返回true,增加失败返回false;* @throws Exception*/public boolean doCreate(V vo)throws Exception;/*** 更新一条数据；* @param vo 简单Java类对象；* @return返回一个boolean对象，更新成功返回true,更新失败返回false;* @throws Exception*/public boolean doUpdate(V vo)throws Exception;/*** 删除一条数据；* @param id 简单Java类对象的id；* @return返回一个boolean对象，删除成功返回true,删除失败返回false;* @throws Exception*/public boolean doRemove(int id)throws Exception;/*** 查询出一条数据，* @param id 数据对应的id* @return返回一个简单java类对象；* @throws Exception*/public K findById(int id)throws Exception;/*** 查询所有的数据；* @return返回一个简单Java类对象；* @throws Exception*/public List<V> findAll()throws Exception;/*** 模糊查询，也是分页要用的一个方法；* @param column 列名称* @param keyWord 关键字* @param currentPage 当前页* @param lineSize 每页现实的数据条目* @return返回一个List集合；* @throws Exception*/public List<V> findAll(String column,String keyWord,IntegercurrentPage,Integer lineSize)throws Exception;/*** 统计模糊查询的条目* @param column 列名称* @param keyWord 关键字* @return返回一个整数* @throws Exception*/public int getAllCount(String column,String keyWord)throws Exception;}·公共的接口开发完成了，我们接下来就开发IEmpDAO接口，这个接口直接继承IDAO 接口即可，是不是很方便，直接继承即可，如果你需要扩充什么方法的话，直接编写方法即可，package cn.oracle.dao;import cn.oracle.pojo.Emp;public interface IEmpDAO extends IDAO<Integer, Emp> {}·然后当然是编写接口的实现类了，也就是编写方法的具体实现，EmpDAOImpl.javapackage cn.oracle.dao.impl;import java.util.List;import javax.annotation.Resource;import org.hibernate.Criteria;import org.hibernate.Query;import org.hibernate.SessionFactory;import ponent;import cn.oracle.dao.IEmpDAO;import cn.oracle.pojo.Emp;@Component→这个就是Annotation注解，其实你可以理解为在applicationContext.xml文件之中配置了一个bean<bean id=”empDAOImpl” class=”cn.oracle.dao.impl.EmpDAOImpl”>→Component<property name=”sessionFactory” ref=”sessionFactory”/>→Resource</bean>public class EmpDAOImpl implements IEmpDAO {@Resourceprivate SessionFactory sessionFactory;@Overridepublic boolean doCreate(Emp vo) throws Exception {return this.sessionFactory.getCurrentSession().save(vo) != null;}→使用Session接口的save方法来保存数据；@Overridepublic boolean doUpdate(Emp vo) throws Exception {String hql="UPDATE Emp AS e SET e.ename=?,e.hiredate=?,e.sal=? WHERE e.empno=?";Query query=this.sessionFactory.getCurrentSession().createQuery(hql);query.setString(0, vo.getEname());query.setDate(1, vo.getHiredate());query.setString(2, vo.getSal());return query.executeUpdate()>0;}→使用Query实现更新；@Overridepublic boolean doRemove(int id) throws Exception {String hql="DELETE FROM Emp As e WHERE e.empno=?";Query query=this.sessionFactory.getCurrentSession().createQuery(hql);query.setInteger(0, id);return query.executeUpdate()>0;}→使用Query接口实现删除；@Overridepublic Emp findById(int id) throws Exception {return (Emp) this.sessionFactory.getCurrentSession().get(Emp.class, id);}→使用Session接口查询数据；@SuppressWarnings("unchecked")@Overridepublic List<Emp> findAll() throws Exception {Criteriacriteria=this.sessionFactory.getCurrentSession().createCriteria(Emp.class);List<Emp> all=criteria.list();return all;} →使用criteria接口实现全部查询；@SuppressWarnings("unchecked")@Overridepublic List<Emp> findAll(String column, String keyWord,Integer currentPage, Integer lineSize) throws Exception { String hql="FROM Emp AS e WHERE e."+column+" LIKE ?";Query query=this.sessionFactory.getCurrentSession().createQuery(hql);query.setString(0, "%"+keyWord+"%");query.setFirstResult((currentPage-1)*lineSize);query.setMaxResults(lineSize);return (List<Emp>)query.list();}→使用query接口实现分页模糊查询；@Overridepublic int getAllCount(String column, String keyWord) throws Exception { String hql="SELECT COUNT(e.empno) FROM Emp AS e WHERE "+column+" LIKE ?";Query query=this.sessionFactory.getCurrentSession().createQuery(hql);query.setString(0, "%"+keyWord+"%");Integer count=((Long)query.uniqueResult()).intValue();return count;} →使用query接口完成统计；}·编写完成DAO层之后，我们就要做的就是编写服务层了，也就是对DAO层接口的调用，IEmpService.javapackage cn.oracle.service;import java.util.List;import java.util.Map;import cn.oracle.pojo.Emp;public interface IEmpService {public boolean insert(Emp vo)throws Exception;public boolean update(Emp vo)throws Exception;public boolean delete(int id)throws Exception;public Emp get(int id)throws Exception;public List<Emp> list()throws Exception;public Map<String ,Object> list(String column,String keyWord,Integer currentPage,Integer lineSize)throws Exception;}·接口编写完成，之后我们就应该编写实现类了；EmpServiceImpl.javapackage cn.oracle.service.impl;import java.util.HashMap;import java.util.List;import java.util.Map;import javax.annotation.Resource;import org.springframework.stereotype.Service;import cn.oracle.dao.IEmpDAO;import cn.oracle.pojo.Emp;import cn.oracle.service.IEmpService;@Service Service层的专用Annotation注解；public class EmpServiceImpl implements IEmpService {@Resourceprivate IEmpDAO empDAO;@Overridepublic boolean insert(Emp vo) throws Exception {return this.empDAO.doCreate(vo);}@Overridepublic boolean update(Emp vo) throws Exception {return this.empDAO.doUpdate(vo);}@Overridepublic boolean delete(int id) throws Exception {return this.empDAO.doRemove(id);}@Overridepublic Emp get(int id) throws Exception {return this.empDAO.findById(id);}@Overridepublic List<Emp> list() throws Exception {return this.empDAO.findAll();}@Overridepublic Map<String, Object> list(String column, String keyWord,Integer currentPage, Integer lineSize) throws Exception { Map<String ,Object> map=new HashMap<String,Object>();map.put("allEmps", this.empDAO.findAll(column, keyWord, currentPage, lineSize));map.put("allCount", this.empDAO.getAllCount(column, keyWord));return map;}}·到此，后台业务层的增删改查就完成了，然后就是控制器的编写了，我们用的是springmvc的话，自然编写起来很方便的；EmpAction.javapackage cn.oracle.action;import java.util.List;import javax.annotation.Resource;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestMethod;import org.springframework.web.servlet.ModelAndView;import cn.oracle.pojo.Emp;import cn.oracle.service.IEmpService;@Controller→spring mvc的专用annotation注解，代表一个控制器；@RequestMapping("/pages/front/emp/*") →映射路径public class EmpAction {@Resourceprivate IEmpService empService;@RequestMapping(value="emp_list.jsp",method=RequestMethod.GET)public ModelAndView list(HttpServletRequest request,HttpServletResponse response){List<Emp> allEmps=null;try {allEmps=this.empService.list();} catch (Exception e) {e.printStackTrace();}ModelAndView mav=new ModelAndView();mav.setViewName("/pages/front/emp/emp_list.jsp");mav.addObject("allEmps", allEmps);System.out.println(allEmps); 我们就用一个简单的连接做测试，如果后台输出了这些对象的话，说明我们就完成了页面的操作了；return mav;}}如果后台有输出这些信息，说明你的所有配置正常，开发CRUD没任何问题的；。

Struts2的CRUD简单实例CRUD是Create（创建）、Read（读取）、Update（更新）和Delete（删除）的缩写，它是普通应用程序的缩影。

取而代之的是一个模拟数据库的哈希表（Hash Map）。

具体实现首先，让我们看看的“冒牌”的DAO（Data Access Object，数据访问对象），代码如下：package com.meng.book;import java.util.Collection;import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.ConcurrentMap;public class BookDao {private static final BookDao instance;private static final ConcurrentMap<String, Book> data;static {instance = new BookDao();data = new ConcurrentHashMap<String, Book>();data.put("978-0735619678", new Book("978-0735619678", "Code Complete, Second Edition", 32.99));data.put("978-0596007867", new Book("978-0596007867", "The Art of Project Management", 35.96));data.put("978-020*******", new Book("978-020*******", "Design Patterns: Elements of Reusable Object-Oriented Software", 43.19));data.put("978-0596527341", new Book("978-0596527341", "Information Architecture for the World Wide Web: Designing Large-Scale Web Sites", 25.19));data.put("978-0735605350", new Book("978-0735605350", "Software Estimation: Demystifying the Black Art", 25.19));}private BookDao() {}public static BookDao getInstance() {return instance;}public Collection<Book> getBooks() {return data.values();}public Book getBook(String isbn) {return data.get(isbn);}public void storeBook(Book book) {data.put(book.getIsbn(), book);}public void removeBook(String isbn) {data.remove(isbn);}public void removeBooks(String[] isbns) {for(String isbn : isbns) {data.remove(isbn);}}}接下来是的数据模型Book类，代码如下：package com.meng.book;import java.io.Serializable;public class Book implements Serializable{private String isbn;private String title;private double price;public Book() {}public Book(String isbn, String title, double price) {this.isbn = isbn;this.title = title;this.price = price;}public String getIsbn() {return isbn;}public void setIsbn(String isbn) {this.isbn = isbn;}public double getPrice() {return price;}public void setPrice(double price) {this.price = price;}public String getTitle() {return title;}public void setTitle(String title) {this.title = title;}}Book类有三个属性isbn,、title和price分别代表书籍的编号、名称和价格，其中编号用于唯一标识书籍（相当数据库中的主键）。

SSH框架下CRUD及验证完整实例(一)一准备工作●目标和工具在学习Java两个月之后,尝试使用学过的东西写一个最简单的页面,实现对一张数据库进行基本的CRUD操作和分页,顺便增加服务端验证和Ajax动态验证以及简单的验证码.使用的工具和环境如下:SSH框架(Struts2.1.6,Spring2.5,Hibernate3.2), Myeclipse8.0, Oracle10g数据库,JS类库prototype.js,json2.js. 数据库连接池使用的是proxool,应用到的jar 包如下图,其中dojo和dwr两个插件是后期添加功能时要用,本实例没有用到,在添加项目Hibernate和Spring支持的时候冲突的架包已经删除.●项目的目录结构源文件的目录结构如左图,其中pass文件夹放的是一些历史文件,和本例无关.项目按照mvc框惯例,分为action, dao, model, service, web五层.jsp文件如右图所示放在了WebRoot/per文件夹下,连同js库文件,其中register.jsp是测试验证码使用的.项目对应的数据库表二开发步骤首先新建web项目crm,依次为项目添加SSH支持,接着用工具或命令在数据库中建立数据表PERSON,4个列ID,NAME,AGE,ADDRESS,其中ID为主键.接着在Myeclipse中打开database 试图,为数据库新建一个连接或者使用已有的连接.接下来可以选择直接在database试图中选中PERSON表使用Hibernate反向工程自动生成实体Dao和映射表,也可以自己编写这些文件,相关代码如下.model层,包名com.person.crm.modelDao层,包名com.person.crm.dao业务层service 包名com.person.crm.service PersonManager.java 业务层接口●web层包名com.person.crm.web一个用于生成验证码的类●action层负责处理用户请求包名com.person.crm.actionPersonAction.properties处理PersonAction中类型转换错误信息PersonAction-add-validation.xml和PersonAction-update-validation.xml。

机场登机桥故障诊断知识管理系统
信息化是当今社会发展的必然趋势，是衡量一个企业管理水平高低的重要标志之一。

在登机桥维修管理中，由于登机桥故障诊断知识的来源十分广泛，信息要素复杂多样，可用性较差，很难将其有效的融合、利用，如何将这些存储格式各异、信息结构不统一的登机桥故障诊断知识进行集成和管理，实现登机桥故障诊断知识的共享与重用，是登机桥故障诊断知识管理有待解决的问题。

为解决以上问题，本文将本体引入到登机桥故障诊断知识管理中，构建了登机桥故障诊断知识管理系统。

本文首先对S机场实习做了总结，从登机桥结构和工作原理、登机桥常见故障及排除、登机桥点检三个方面介绍了登机桥故障诊断知识的来源。

为后面的登机桥故障诊断知识本体构建提供了知识资源。

然后构建了登机桥故障诊断知识本体，研究了登机桥故障诊断知识的检索技术，提出了基于语义检索的登机桥故障知识流程，将语义检索引入登机桥本体检索中，实现了登机桥故障知识检索的语义扩展，提高了检索的效率与准确性，且给出了检索的具体算法与检索实例。

最后在在登机桥故障知识本体和登机桥故障知识语义检索的基础上，采用B/S结构，JAVA（ExtJs4+Struts2+Hibernate+Spring）语言，开发了登机桥故障诊断知识管理系统。

利用crudrepository接口实现功能的总结利用CrudRepository接口实现功能的总结[引言]在现代软件开发中，数据处理是一个极为重要的环节。

为了简化开发过程，许多开发人员选择使用现成的框架来处理与数据库的交互。

Spring框架是一个广泛使用的Java框架，其中有一个非常有用的接口叫做CrudRepository，能够大大简化数据库操作的过程。

本文将介绍CrudRepository接口的功能和使用方法，并重点讨论如何利用CrudRepository接口实现常见的功能。

[正文]1. CrudRepository接口概述CrudRepository接口是Spring框架中的一个核心接口，它提供了常见的增删改查（CRUD）功能。

CrudRepository接口是Spring Data JPA模块的一部分，实现了对数据库的基本操作。

开发人员只需定义一个继承CrudRepository接口的接口，Spring框架会自动生成实现类并提供相应的方法。

2. CrudRepository接口的常用方法CrudRepository接口提供了常用的增删改查方法，其中包括：- save方法：用于保存或更新实体对象。

- delete方法：用于根据实体对象或ID删除记录。

- findAll方法：用于获取所有记录。

- findById方法：用于根据ID获取记录。

- count方法：用于统计记录个数。

3. 利用CrudRepository接口实现创建记录功能创建记录是数据库操作中的基本功能之一。

首先，我们需要定义一个继承CrudRepository接口的接口，并指定实体类类型以及ID类型。

接着，我们在这个接口中添加一个继承自CrudRepository的方法：public interface UserRepository extends CrudRepository<User, Long> { }在这个方法中，我们可以调用CrudRepository的save方法来保存实体对象：User user = new User();user.setName("张三");user.setAge(20);user.setEmail("zhangsan@example");userRepository.save(user);通过调用save方法，我们可以将一个新的用户对象保存到数据库中。

深入浅出的理解框架（Struts2、Hibernate、Spring）与MVC 设计现在许许多多的初学者和程序员，都在趋之若鹜地学习Web开发的宝典级框架：Suts2，Spring，Hibernate。

似乎这些框架成为了一个人是否精通Java，是否会写J2EE程序的唯一事实标准和找工作的必备基础。

然而，假如在面试的时候问这些程序员，你们为什么要学习这些框架？这些框架的本质到底是什么？似乎很少很少有人能够给我十分惬意的答复。

由于他们都在为了学习而学习，为了工作而学习，而不是在真正去深化了解一个框架。

其实全部的人都应当思量这样的问题：为什么要学习框架？框架到底给我带来了什么？接下来，我们以登录作为一个最容易的例子，来看看不同的年月，我们是怎么写Web程序的。

后来，我们放弃了在页面上写规律后来，程序写得越来越多，我们发觉，这种在HTML代码中编写Java代码来完成规律的方式存在着不少问题：1. Java代码因为混杂在一个HTML环境中而显得混乱不堪，可读性十分差。

一个JSP文件有时候会变成几十K，甚至上百K。

要找一段规律，常常无法定位。

2. 编写代码时十分困窘，不知道代码到底应当写在哪里，也不知道别人是不是已经曾经实现过类似的功能，到哪里去引用。

3. 骤然之间，某个需求发生了变幻。

于是，每个人蒙头开头全程替换，还要当心翼翼的，生怕把别人的规律改了。

4. 规律处理程序需要自己来维护生命周期，对于类似数据库事务、日志等众多模块无法统一支持。

在这个时候，假如有一个产品，它能够将页面上的那些Java代码抽取出来，让页面上尽量少浮现Java代码，该有多好。

于是许多人开头用法servlet来处理那些业务规律。

public class LoginServlet tends HttpServlet { /* (non-Javadoc) * @see javax.servlet.http.HttpServletdoPost(javax.servlet.http.Http ServletRequest, javax.servlet.http.HttpServletResponse) */ @Overre protect void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException第1页共2页。

JAVA程序设计中常用的框架技术介绍JAVA是一种广泛使用的编程语言，常用于开发各种应用程序，包括Web应用、移动应用、企业应用等。

为了提高开发效率和代码质量，JAVA 程序设计中常使用各种框架和技术。

下面将介绍JAVA程序设计中常用的框架和技术。

1. Spring框架：Spring框架是一个开源的Java平台，用于简化企业级Java应用程序的开发。

它提供了一种强大的依赖注入（DI）机制，可以简化类之间的依赖关系，并提供了一种轻量级的容器，可以管理和协调Java对象的生命周期。

Spring还提供了MVC框架，用于开发Web应用程序。

Spring还支持事务管理、安全性、缓存等各种功能。

2. Hibernate框架：Hibernate是一个基于Java的对象关系映射（ORM）框架，可以帮助开发人员将Java对象映射到数据库表中。

Hibernate提供了一个简单易用的API，可以处理对象和数据库之间的映射关系，从而使得开发人员可以更专注于业务逻辑而不必关心数据库操作。

Hibernate还提供了查询语言（HQL）和面向对象的查询API，以及缓存和事务管理等功能。

3. Struts框架：Struts是一个MVC框架，用于开发Web应用程序。

它将应用程序分为模型、视图和控制器三个部分，通过控制器将请求分发到合适的处理程序，再通过模型将数据提供给视图展示。

Struts提供了强大的表单验证和数据绑定机制，使得开发人员可以很方便地处理用户输入数据。

Struts 还支持国际化、资源管理等功能。

4. Spring Boot框架：Spring Boot是一个用于创建和运行独立的、生产级的Spring应用程序的框架。

它采用约定优于配置的方式，提供了各种自动化配置和快速启动的能力。

Spring Boot可以帮助开发人员快速地创建Java应用程序，并提供了许多有用的功能和工具，如嵌入式Web服务器、注解驱动的开发、自动化配置、健康检查等。

Java开源框架：Struts、Spring、Hibernate和iBatis 引言在当今软件开发领域，Java是最受欢迎的编程语言之一。

与此同时，Java开源框架也变得越来越流行。

这些框架提供了丰富的功能和工具，使开发人员能够更快速、更高效地构建和维护Java应用程序。

本文将重点介绍四个最受欢迎的Java 开源框架：Struts、Spring、Hibernate和iBatis。

第一章：Struts框架1.1 框架简介Struts是一个基于MVC架构的Web应用程序开发框架。

它通过将应用程序的业务逻辑、数据模型和用户界面分离，使开发人员能够更好地组织和管理代码。

Struts提供了一个可扩展的框架，包括控制器、模型和视图组件。

1.2 核心组件Struts框架的核心组件包括Action类、ActionForm类、配置文件和标签库。

Action类处理用户请求，并将结果返回给用户。

ActionForm类用于封装用户请求的数据。

配置文件用于配置整个应用程序的行为。

标签库提供了用于生成动态HTML页面的标签。

1.3 优点和应用场景Struts框架具有以下优点：- 提供了丰富的功能和工具，如表单验证、国际化支持和异常处理。

- 可以与其他Java技术和框架无缝集成，如Hibernate和Spring。

- 适用于开发大型、复杂的Web应用程序。

第二章：Spring框架2.1 框架简介Spring是一个轻量级的Java开源框架，用于构建企业级Java应用程序。

它提供了依赖注入（DI）和面向切面编程（AOP）等功能，使开发人员能够更容易地编写可测试、可维护和可扩展的代码。

2.2 核心组件Spring框架的核心组件包括IoC容器、AOP模块、数据访问模块和Web模块。

IoC容器负责管理应用程序中的对象，并处理它们之间的依赖关系。

AOP模块提供了面向切面编程的支持。

数据访问模块提供了对数据库的访问功能。

Web 模块用于构建Web应用程序。

系统可作为OA、网站、电子政务、ERP、CRM、APP后台等基于B/S架构的应用软件系统的快速开发框架。

一、特色功能1、采用Spring MVC的静态加载缓存功能，在首页将Javascript文件、CSS文件和图片等静态资源文件加载进来放进内存，极大提高ExtJS的加载速度。

2、三种皮肤主题：经典、灰色和海王星，支持多浏览器和多分辨率。

3、分别封装了模型层、控制层、业务逻辑层和数据持久层的通用操作模块，层次分明，大大减少代码冗余，二次开发效率高。

4、系统是公司多个项目的基础框架，稳定性好，支持大并发。

二、主要功能1、采用ExtJS 4.2.1.883无限制版本，放心用于网站开发。

2、ExtJS富文本编辑器增加修改信息。

3、ExtJS的HtmlEditor的图片文件上传插件。

4、Grid列表和表单，包含添加、删除、批量删除、修改、查看、图片查看和按条件查询列表等功能。

5、导入导出Excel数据，支持xlsx和xls文件。

6、资源管理（菜单管理）。

7、用户管理和部门管理。

8、权限管理。

不仅可管理各个功能模块的权限，也可以管理功能模块里的页面按钮权限。

9、报表统计。

也可以嵌入其他报表工具插件。

10、采用开源的互动地图Javascript库Leaflet，处理自定义在线地图。

Panel里包含2个组件，在2个组件间传递参数显示数据。

三、开发工具和采用技术1、开发工具：Eclipse、MyEclipse和其他IDE。

2、采用Spring 3中最新最稳定的Spring MVC 3.2.8版本。

3、采用Hibernate 4.1.7。

Spring MVC 3.2.8支持的最高Hibernate版本是4.1.7，更高的Hibernate版本和Spring MVC 3.2.8组合会遇到兼容问题。

4、Hibernate集成二级缓存框架Ehcache。

5、数据库是MySQL、Oracle和SQL Server，Hibernate的Dialect可使程序移植到其他数据库。

Hibernate回顾CRUDHibernate配置文件<?xml version='1.0' encoding='utf-8'?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD//EN""src/dtd/hibernate-configuration-3.0.dtd"><hibernate-configuration><session-factory><!--一个sessionFactory代表一个数据库描述--><!--链接数据库的URL--><property name="connection.url">jdbc:mysql://localhost:3306/itheima?characterEncoding=UTF-8</property><!--链接数据库的驱动--><property name="connection.driver_class">com.mysql.jdbc.Driver</property><!--链接数据库的密码--><property name="ername">root</property><!--链接数据库的用户名--><property name="connection.password">1234</property><!-- DB schema will be updated if needed --><!-- <property name="hbm2ddl.auto">update</property> --><!--方言--><!--告诉hibernate用什么样的数据库，将来会生成什么样的语句--><property name="dialect">org.hibernate.dialect.MySQLDialect</property><!--hibernate 对表的策略validate 在hibernate 容器启动的时候，根据映射文件和持久化类来校验表create 每次当hibernate启动的时候，都会根据持久化类和映射文件来创建表create-drop 每次当hibernate 启动的时候都会根据持久化类和映射文件来创建表和删除表update 检查，如果映射文件不一致，则更新表结构,如果没有表则创建表//如果把Person.hdm/xml ，中的column 修改，则表结构会新添加一列造成结果是表中产生两个主键--><property name="hbm2ddl.auto">update</property><!--//加载映射文件--><!--显示ＳＱＬ语句--><property name="show_sql">true</property><mappingresource="com/sanmao/hibernate/crud/domain/Person.hbm.xml" /> </session-factory></hibernate-configuration>`这里写代码片`package com.sanmao.hibernate.crud.domain;import java.io.Serializable;/*** Created by root on 16-9-18.*/public class Person implements Serializable {//实现序列化能够用二进制在网络传输,所以分布式要实现中的类要实现序列化private Long pid;private String name;private String sex;public Long getPid() {return pid;}public void setPid(Long pid) {this.pid = pid;}public String getName() {return name;}public void setName(String name) { = name;}public String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}@Overridepublic String toString() {return "Person{" +"pid=" + pid +", name='" + name + '\'' +", sex='" + sex + '\'' +'}';}}持久化类的映射文件<?xml version="1.0" encoding="utf-8"?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN""src/dtd/hibernate-mapping-3.0.dtd"><hibernate-mapping><!--class 元素代表持久化类--><!--name属性为类的全名--><!--table 表名，默认值是类名--><!--catalog 数据库的名字--><class name="com.sanmao.hibernate.crud.domain.Person"><!--id为主键元素--><!--name 标识符属性--><!--length 数据库中pid 的长度--><!--column pid 属性对应的字段--><id name="pid" length="5" column="pid" type="ng.Long"><!--主键的产生器--><!--需要什么样的方式产生主键--><generator class="increment"></generator><!--<generator class="assigned"></generator>--></id><!--代表一般的属性--><property name="name" length="20"></property><property name="sex" length="20"></property></class></hibernate-mapping>创建表package com.sanmao.hibernate.createtable;import org.hibernate.SessionFactory;import org.hibernate.cfg.Configuration;import org.junit.Test;/*** Created by root on 16-9-18.*/public class CreateTableTest {@Testpublic void testCreateTable(){// 加载了hibernate的文件Configuration configuration=new Configuration();// 要求的配置文件的路径// 1.必须是classpath的根目录// 2.文件的名称必须是hibernate.cfg.xml// 加载方式一configuration.configure();// 方法二，指定要加载的文件// configuration.configure(""); //参数为hibernate配置文件的路径及名称// <!--一个sessionFactory代表一个数据库描述-->SessionFactory sessionFactory=configuration.buildSessionFactory();}}增删改查package com.sanmao.hibernate.crud.test;import com.sanmao.hibernate.crud.domain.Person;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.Transaction;import org.hibernate.cfg.Configuration;import org.junit.Test;import java.util.List;/*** 完成crud的操作*/public class CRUDTest {/*** 存储操作*/@Testpublic void testSave(){/** 创建sessionFactory* 1.sessionFactory是单例的* 2. hibernate的配置文件的信息* ，映射文件的信息，持久化类的信息全部在sessionFactory中* 3.sessionFactory封装的信息都是公共的数据* 4.sessionFactory 本身是线程安全的，* */Configuration configuration=new Configuration();configuration.configure();//加载了配置文件SessionFactory sessionFactory=configuration.buildSessionFactory();//跟HTTP 中的Session 没有一点关系，就是Hibernate内部自己的Session //保存操作是由session来完成的//openSession 方法相当于利用session打开了一个数据库链接Session session=sessionFactory.openSession();//开启一个事务//hibernate 的事务默认是关闭的，必须手动开启，可以保证数据的安全性Transaction action=session.beginTransaction();Person person=new Person();person.setName("三毛2");person.setSex("男");session.save(person);mit();//相当于关闭了一个连接session.close();}/*** 查询操作*/@Testpublic void testQueryAllPerson(){Configuration configuration=new Configuration();configuration.configure();SessionFactory sessionFactory=configuration.buildSessionFactory();Session session=sessionFactory.openSession();/*** HQL : hibernate query language* *///返回所有personsList<Person> persons=session.createQuery("from Person ").list();for (Person p: persons) {System.out.println(p);}session.close();}/*** 通过主键获取对象*/@Testpublic void getPersonById(){Configuration configuration=new Configuration();configuration.configure();SessionFactory sessionFactory=configuration.buildSessionFactory();Session session=sessionFactory.openSession();/*** 第一个参数为持久化类的class形式* 第二个参数就是主键，类型必须和持久化类中的主键保持一致* *///在持久化类中主键类型为ＬＯＮＧ所以，要将１转换为ＬＯＮＧ类型// Person person=(Person) session.get(Person.class,1);Person person=(Person) session.get(Person.class,1L);System.out.println(person);session.close();}/*** 更新对象*/@Testpublic void testUpdatePerson(){Configuration configuration=new Configuration();configuration.configure();SessionFactory sessionFactory=configuration.buildSessionFactory();Session session=sessionFactory.openSession();//开启事务Transaction transaction=session.beginTransaction();Person person=(Person) session.get(Person.class,1L);person.setName("yongchao");//应该是根据主键定位session.update(person);mit();session.close();}/*** 删除操作*/@Testpublic void testDeletePerson(){Configuration configuration=new Configuration();configuration.configure();SessionFactory sessionFactory=configuration.buildSessionFactory();Session session=sessionFactory.openSession();//开启事务Transaction transaction=session.beginTransaction();Person person=(Person) session.get(Person.class,1L);session.delete(person);mit();session.close();}}。