项目介绍
java 开发中，参数校验是非常常见的需求。
但是 hibernate-validator 在使用过程中，依然会存在一些问题。
特性
?支持 fluent-validation
?支持 jsr-303 注解
?支持 i18n
?支持用户自定义策略
?支持用户自定义注解
开源地址
valid
创作目的
hibernate-validator 无法满足的场景
如今 java 最流行的 hibernate-validator 框架，但是有些场景是无法满足的。比如：
1.验证新密码和确认密码是否相同。(同一对象下的不同属性之间关系)
2.当一个属性值满足某个条件时，才进行其他值的参数校验。
3.多个属性值，至少有一个不能为 null
其实，在对于多个字段的关联关系处理时，hibernate-validator 就会比较弱。本项目结合原有的优点，进行这一点的功能强化。
validation-api 过于复杂
validation-api 提供了丰富的特性定义，也同时带来了一个问题。
实现起来，特别复杂。
然而我们实际使用中，常常不需要这么复杂的实现。
valid-api 提供了一套简化很多的 api，便于用户自行实现。
自定义缺乏灵活性
hibernate-validator 在使用中，自定义约束实现是基于注解的，针对单个属性校验不够灵活。
本项目中，将属性校验约束和注解约束区分开，便于复用和拓展。
过程式编程 vs 注解式编程
hibernate-validator 核心支持的是注解式编程，基于 bean 的校验。
一个问题是针对属性校验不灵活，有时候针对 bean 的校验，还是要自己写判断。本项目支持 fluent-api 进行过程式编程，同时支持注解式编程。
尽可能兼顾灵活性与便利性。
项目模块说明
模块名称说明
valid-api 核心 api 及注解定义
valid-core 针对 valid-api 的核心实现
valid-jsr 针对 JSR-303 标准注解的实现
valid-test 测试代码模块
依赖说明
valid-core 默认引入 valid-api
valid-jsr 默认引入 valid-core
快速开始
准备工作
JDK1.7+
Maven 3.X+
maven 引入
例子
我们直接利用 jsr 内置的约束类：
public void helloValidTest() {
IResult result = ValidBs.on(null, JsrConstraints.notNullConstraint ())
.result()
.print();
Assert.assertFalse(result.pass());
}
对应日志输出为：
DefaultResult{pass=false, notPassList=[DefaultConstraintResult{pass=fal se, message='预期值为
方法初步说明
ValidBs 用来进行验证的引导类，上述的写法等价于如下：
public void helloValidAllConfigTest() {
IResult result = ValidBs.on(null, JsrConstraints.notNullConstraint ())
.fail(Fails.failFast())
.group()
.valid(DefaultValidator.getInstance())
.result()
.print();
Assert.assertFalse(result.pass());
}
on(Object value, IConstraint… constraints) 指定约束
Object 可以是对象，也可以是普通的值。
constraints 为对应的约束列表，为默认的约束验证提供便利性。
IConstraint 相关创建工具类Constraints、JsrConstraints
fail(IFail fail)
可以指定失败时的处理策略，支持用户自定义失败策略。
实现说明
failOver 失败后继续验证，直到验证完所有属性
failFast 失败后快速返回
group(Class[] classes) 支持分组验证
有时候我们希望，只验证指定某一分组的约束。
可以通过 group() 属性指定，与 IConstraint 中的 group() 属性匹配的约束才会被执行。
valid(IValidator validator) 支持验证策略
默认为 DefaultValidator，为 valid-api 的实现验证。
如果你希望使用 jsr-303 注解，可以使用JsrValidator。
支持自定义验证策略。
result(IResultHandler resultHandler) 验证结果处理
默认为 simple() 的简单结果处理。
可以指定为 detail() 进行详细结果处理查看。
支持用户自定义结果处理策略。
IResult 内置方法
simple()/detail() 处理的结果为 IResult 实现类。
IResult 支持如下方法：
?print()
对结果进行打印，主要便于调试。
?throwEx()
对于参数的校验，一般都是基于异常结合 spring aop来处理的。
throwsEx 会在验证不通过时，抛出 ValidRuntimeException 异常，对应 message 为提示消息。
@Test(expected = ValidRuntimeException.class)
public void resultThrowsExTest() {
ValidBs.on(null, notNullValidatorEntry())
.valid()
.result()
.throwsEx();
}
内置的属性约束
上面我们对 ValidBs 有了一个整体的了解，下面来看一看系统内置的属性约束有哪些。
每个属性约束都有对应注解。
针对单个属性，直接使用属性约束即可，灵活快捷。
针对 bean 校验，可以结合注解实现，类似于 hibernate-validator。
valid-core
核心内置属性约束实现。
enumRangesConstraint
枚举类指定范围约束
?创建方式
参见工具类Constraints#enumRangesConstraint
/**
*枚举范围内约束
*（1）当前值必须在枚举类对应枚举的 toString()列表中。
* @param enumClass 枚举类，不可为空
*@return 约束类
*@since 0.1.1
*@see com.github.houbb.valid.core.annotation.constraint.EnumRanges 枚举类指定范围注解
*/
public static IConstraint enumRangesConstraint(final Class enumClass)
?测试案例
参见测试类 EnumsRangesConstraintTest
IResult result = ValidBs.on("DEFINE", Constraints.enumRangesConstraint (FailTypeEnum.class))
.result();
Assert.assertFalse(result.pass());
?说明
FailTypeEnum 是 valid-api 内置的枚举类，枚举值为 FAIL_FAST/FAIL_OVER。
只有属性值在枚举值范围内，验证才会通过。
rangesConstraint
指定属性范围内约束
?创建方式
参见工具类Constraints#rangesConstraint
* 值在指定范围内约束
* （1）这里为了和注解保持一致性，暂时只支持 String
* @param strings 对象范围
* @return约束类
* @since0.1.1
* @see com.github.houbb.valid.core.annotation.constraint.Ranges String 指定范围内注解
*/
public static IConstraint rangesConstraint(String ... strings)
?测试案例
参见测试类 RangesConstraintTest
IResult result = ValidBs.on("DEFINE", Constraints.rangesConstraint("FAI L_OVER",
"FAIL_FAST"))
.result();
Assert.assertFalse(result.pass());
?说明
这个相对于枚举值，更加灵活一些。
可以根据自己的需要，指定属性的范围。
valid-jsr
valid-jsr 中内置注解，和 jsr-303 标准一一对应，此处不再赘述。
创建方式见工具类JsrConstraints，测试代码见 xxxConstraintTest。
对应列表如下：
属性约束注解简介
AssertFalseConstraint @AssertFalse 指定值必须为 false AssertTrueConstraint @AssertTrue 指定值必须为 true
MinConstraint @Min 指定值必须大于等于最小值
MaxConstraint @Max 指定值必须小于等于最大值DecimalMinConstraint @DecimalMin 指定金额必须大于等于最小值DecimalMaxConstraint @DecimalMax 指定金额必须小于等于最大值DigitsConstraint @Digits 指定值位数必须符合要求FutureConstraint @Future 指定日期必须在未来
PastConstraint @Past 指定日期必须在过去PatternConstraint @Pattern 指定值必须满足正则表达式SizeConstraint @Size 指定值必须在指定大小内
自定义约束实现
需求
实际业务需求的是不断变化的，内置的属性约束常常无法满足我们的实际需求。我们可以通过自定义属性，来实现自己的需求。
例子
参见类 DefineConstraintTest
自定义 notNullConstraint
notNullConstraint 对于 null 值是严格的。
所以继承自AbstractStrictConstraint，如下：
IResult result = ValidBs.on(null, new AbstractStrictConstraint() { @Override
protected boolean pass(IConstraintContext context, Object value) { return value != null;
}
}).result();
Assert.assertFalse(result.pass());
自定义 assertTrueConstraint
在 jsr-303 标准中，除却@NotNull对于 null 值都是非严格校验的。
继承自AbstractConstraint即可，如下：
IConstraint assertTrueConstraint = new AbstractConstraint
protected boolean pass(IConstraintContext context, Boolean value) {
return false;
}
};
IResult nullValid = ValidBs.on(null, assertTrueConstraint) .result();
Assert.assertTrue(nullValid.pass());
IResult falseValid = ValidBs.on(false, assertTrueConstraint) .result();
Assert.assertFalse(falseValid.pass());
core 模块注解验证
内置注解
注解说明
@AllEquals 当前字段及指定字段值必须全部相等
@HasNotNull 当前字段及指定字段值至少有一个不为 null
@EnumRanges 当前字段值必须在枚举属性范围内
@Ranges 当前字段值必须在指定属性范围内
测试对象
?User.java
public class User {
/**
*名称
*/
@HasNotNull({"nickName"})
private String name;
/**
*昵称
*/
private String nickName;
/**
*原始密码
*/
@AllEquals("password2")
private String password;
/**
*新密码
*/
private String password2;
/**
*性别
*/
@Ranges({"boy", "girl"})
private String sex;
/**
*失败类型枚举
*/
@EnumRanges(FailTypeEnum.class)
private String failType;
//fluent getter & setter
}
我们限制 name/nickName 至少有一个不为空，password/password2 值要一致。以及限定了 sex 的范围值和 failType 的枚举值。
测试代码
User user = new User();
user.sex("what").password("old").password2("new")
.failType("DEFINE");
IResult result = ValidBs.on(user)
.fail(Fails.failOver())
.result()
.print();
Assert.assertFalse(result.pass());
?日志
DefaultResult{pass=false, notPassList=[DefaultConstraintResult{pass=fal se, message='值
jsr 模块注解验证
注解
与 jsr-303 注解标准保持一致。
对象定义
为了演示，简单定义如下：?JsrUser.java
public class JsrUser {
@Null
private Object nullVal;
@NotNull
private String notNullVal;
@AssertFalse
private boolean assertFalse;
@AssertTrue
private boolean assertTrue;
@Pattern(regexp = "[123456]{2}")
private String pattern;
@Size(min = 2, max = 5)
private String size;
@DecimalMax("12.22")
private BigDecimal decimalMax;
@DecimalMin("1.22")
private BigDecimal decimalMin;
@Min(10)
private long min;
@Max(10)
private long max;
@Past
private Date past;
@Future
private Date future;
@Digits(integer = 2, fraction = 4)
private Long digits;
//fluent getter and setter
}
测试代码
参见测试类ValidBsJsrBeanTest
public void beanFailTest() {
Date future = DateUtil.getFormatDate("90190101", DateUtil.PURE_DATE _FORMAT);
Date past = DateUtil.getFormatDate("20190101", DateUtil.PURE_DATE_F ORMAT);
JsrUser jsrUser = new JsrUser();
jsrUser.assertFalse(true)
.assertTrue(false)
.decimalMin(new BigDecimal("1"))
.decimalMax(new BigDecimal("55.55"))
.min(5)
.max(20)
.digits(333333L)
.future(past)
.past(future)
.nullVal("123")
.notNullVal(null)
.pattern("asdfasdf")
.size("22222222222222222222");
IResult result = ValidBs.on(jsrUser)
.fail(Fails.failOver())
.valid(JsrValidator.getInstance())
.result()
.print();
Assert.assertFalse(result.pass());
}
?日志
DefaultResult{pass=false, notPassList=[DefaultConstraintResult{pass=fal se, message='值必须为空', value=123, constraint='NullConstraint', expect Value='null'}, DefaultConstraintResult{pass=false, message='值必须为非空', value=null, constraint='NotNullConstraint', expectValue='not null'}, DefaultConstraintResult{pass=false, message='值必须为假', value=true, c
onstraint='AssertFalseConstraint', expectValue='false'}, DefaultConstra intResult{pass=false, message='值必须为真', value=false, constraint='Ass ertTrueConstraint', expectValue='true'}, DefaultConstraintResult{pass=f alse, message='值必须满足正则表达式', value=asdfasdf, constraint='Pattern Constraint', expectValue='必须匹配正则表达式 [123456]{2}'}, DefaultConstr aintResult{pass=false, message='值必须为在指定范围内', value=222222222222 22222222, constraint='SizeConstraint', expectValue='大小必须在范围内 [2, 5]'}, DefaultConstraintResult{pass=false, message='值必须小于金额最大值', value=55.55, constraint='DecimalMaxConstraint', expectValue='小于等于 1 2.22'}, DefaultConstraintResult{pass=false, message='值必须大于金额最小值', value=1, constraint='DecimalMinConstraint', expectValue='大于等于 1.2 2'}, DefaultConstraintResult{pass=false, message='值必须大于最小值', val ue=5, constraint='MinConstraint', expectValue='大于等于 10'}, DefaultCon straintResult{pass=false, message='值必须小于最大值', value=20, constrai nt='MaxConstraint', expectValue='小于等于 10'}, DefaultConstraintResult {pass=false, message='时间必须在过去', value=Fri Jan 01 00:00:00 CST 901 9, constraint='PastConstraint', expectValue='小于等于 Sun Oct 13 12:12:0 7 CST 2019'}, DefaultConstraintResult{pass=false, message='时间必须在未
来', value=Tue Jan 01 00:00:00 CST 2019, constraint='FutureConstraint', expectValue='大于等于 Sun Oct 13 12:12:07 CST 2019'}, DefaultConstraint Result{pass=false, message='值必须满足位数', value=333333, constraint='D igitsConstraint', expectValue='整数位数 [2], 小数位数 [4]'}], allList=nu ll}
@Valid 递归属性验证
需求
有时候我们一个对象中，会引入其他子对象。
我们希望对子对象也进行相关属性的验证，这时候就可以使用@Valid注解。
该注解为 jsr-303 标准注解。
对象定义
public class ValidUser {
/**
*子节点
*/
@Valid
private User user;
//fluent setter & getter
}
参见测试类ValidBsValidBeanTest
public void beanFailTest() {
User user = new User();
user.sex("default").password("old").password2("new")
.failType("DEFINE");
ValidUser validUser = new ValidUser();
https://www.doczj.com/doc/9713670353.html,er(user);
IResult result = ValidBs.on(validUser)
.fail(Fails.failOver())
.result()
.print();
Assert.assertFalse(result.pass());
}
?日志信息
DefaultResult{pass=false, notPassList=[DefaultConstraintResult{pass=fal se, message='值
='值
不是预期值', value=default, constraint='RangesConstraint', expectValue=
''}, DefaultConstraintResult{pass=false, message='值
自引用问题
有时候我们可能会引用自身，这个也做了测试，是符合预期的。
参见ValidBsSelfValidBeanTest
i18n 支持
需求
不同国家对于语言的要求肯定也不同。
本项目目前支持中文/英文国际化支持，默认以当前地区编码为准，如果不存在，
则使用英文。
感觉其他语言，暂时使用中没有用到。（个人也不会，错了也不知道。暂时不添加）
测试代码参加ValidBsI18NTest
public void i18nEnTest() {
Locale.setDefault(Locale.ENGLISH);
IResult result = ValidBs.on(null, JsrConstraints.notNullConstraint ())
.result()
.print();
Assert.assertEquals("Expect is
}
指定为中文
public void i18nZhTest() {
Locale.setDefault(Locale.CHINESE);
IResult result = ValidBs.on(null, JsrConstraints.notNullConstraint ())
.result()
.print();
Assert.assertEquals("预期值为
}
IFail 失败策略接口详解
需求
对于不符合约束条件的处理方式，主要有以下两种：
?failFast
快速失败。遇到一个约束不符合条件，直接返回。
优点：耗时较短。
?failOver
全部验证，将所有的属性都验证一遍。
优点：可以一次性获得所有失败信息。
创建方式
参见工具类Fails，返回的实例为单例，且线程安全。
测试代码
参见测试类ValidBsFailTest
failFast
我们指定要求属性值长度最小为3，且必须满足正则表达式。
IResult result = ValidBs.on("12", JsrConstraints.sizeConstraintMin(3),
JsrConstraints.patternConstraint("[678]{3}"))
.fail(Fails.failFast())
.result()
.print();
Assert.assertEquals(1, result.notPassList().size());
?日志
采用快速失败模式，只有一个失败验证结果。
DefaultResult{pass=false, notPassList=[DefaultConstraintResult{pass=fal se, message='预期值为 <必须匹配正则表达式 [678]{3}>，实际值为 <12>', value =12, constraint='PatternConstraint', expectValue='必须匹配正则表达式 [678] {3}'}], allList=null}
failOver
保持其他部分不变，我们调整下失败处理策略。
IResult result = ValidBs.on("12", JsrConstraints.sizeConstraintMin(3),
JsrConstraints.patternConstraint("[678]{3}"))
.fail(Fails.failOver())
.result()
.print();
Assert.assertEquals(2, result.notPassList().size());
?日志
此时失败处理结果为2，日志如下：
DefaultResult{pass=false, notPassList=[DefaultConstraintResult{pass=fal se, message='预期值为 <必须匹配正则表达式 [678]{3}>，实际值为 <12>', value =12, constraint='PatternConstraint', expectValue='必须匹配正则表达式 [678] {3}'}, DefaultConstraintResult{pass=false, message='预期值为 <大小必须在范围内 [3, 2147483647]>，实际值为 <2>', value=12, constraint='SizeConstr aint', expectValue='大小必须在范围内 [3, 2147483647]'}], allList=null}
IValidator 验证策略接口详解
需求
为了便于集成不同框架的测试验证，本框架支持 IValidator。
同时也允许用户自定义自己的实现方式。
默认验证器策略-DefaultValidator
指定 valid 对应的验证器，通过ValidBs.valid(IValidator)方法指定。
默认为 DefaultValidator。
该验证策略，支持符合 valid-api 的内置注解，及用户自定义注解。
JSR-303 验证器策略-JsrValidator
JsrValidator 支持jsr-303 标准注解，及valid-api 标准的相关注解实现和约束实现。?使用方式
通过 valid 方法指定即可。
IResult result = ValidBs.on(jsrUser)
.valid(JsrValidator.getInstance())
.result()
.print();
自定义验证器策略
如果你想添加自己的实现，直接实现 IValidator，并且在 valid() 中指定即可。
可以参考 DefaultValidator，建议继承自AbstractValidator。
IResultHandler 结果处理策略接口详解
需求
对于验证的结果，不同的场景，需求也各不相同。
你可能有如下需求：
（1）输出验证失败的信息
（2）输出所有验证信息
（3）针对验证失败的信息抛出异常
（4）对验证结果进行自定义处理。
为了满足上述需求，提供了如下的接口，及内置默认实现。
接口
public interface IResultHandler
/**
*对约束结果进行统一处理
* @param constraintResultList 约束结果列表
*@return 结果
*/
T handle(final List
如果你想自定义处理方式，实现此接口。
并在ValidBs.result(IResultHandler)方法中指定使用即可。
简单实现
?说明
仅仅对没有通过测试的验证结果进行保留。
?测试代码
参见测试代码ValidBsResultHandlerTest
ValidBs.on("12", JsrConstraints.sizeConstraintMin(2))
.result(ResultHandlers.simple())
.print();
?日志
DefaultResult{pass=true, notPassList=[], allList=null}
详细实现
?说明
保留所有验证结果信息，包含通过验证测试的明细信息。
?测试代码
参见测试代码ValidBsResultHandlerTest
ValidBs.on("12", JsrConstraints.sizeConstraintMin(2))
.result(ResultHandlers.detail())
.print();
?测试日志
DefaultResult{pass=true, notPassList=[], allList=[DefaultConstraintResu lt{pass=true, message='null', value=12, constraint='SizeConstraint', ex pectValue='null'}]}
IResult 结果接口详解
说明
IResult 为验证结果处理的内置实现接口。
拥有以下常见方法：
方法说明
pass() 是否通过验证
notPassList() 未通过验证的列表
allList() 所有验证的列表
print() 控台输出验证结果
throwsEx() 针对未通过验证的信息抛出 ValidRuntimeException
测试代码
@Test(expected = ValidRuntimeException.class)
public void methodsTest() {
IResult result = ValidBs.on("12", JsrConstraints.sizeConstraintMin (3))
.result(ResultHandlers.detail())
.print()
.throwsEx();
Assert.assertFalse(result.pass());
Assert.assertEquals(1, result.notPassList().size());
Assert.assertEquals(1, result.allList().size());
}
?日志
DefaultResult{pass=false, notPassList=[DefaultConstraintResult{pass=fal se, message='预期值为 <大小必须在范围内 [3, 2147483647]>，实际值为 <2>', v alue=12, constraint='SizeConstraint', expectValue='大小必须在范围内 [3, 2147483647]'}], allList=[DefaultConstraintResult{pass=false, message='预期值为 <大小必须在范围内 [3, 2147483647]>，实际值为 <2>', value=12, cons traint='SizeConstraint', expectValue='大小必须在范围内 [3, 2147483647] '}]}
IConstraint 约束接口详解
需求
Hibernate-validator 主要是基于注解的 Bean 验证，所以将注解和实现耦合在了一起。
Valid 作为一个 fluent-api 验证框架，支持过程式编程，所以将针对属性验证的约束独立出来，便于复用。
接口说明
public interface IConstraint {
/**
*触发约束规则
* @param context 上下文
*@return 结果
*@since 0.0.3
*/
IConstraintResult constraint(final IConstraintContext context);
}
自定义说明
前面的例子已经演示了如何自定义实现。
直接实现上述接口也可以，建议继承AbstractConstraint等内置的各种约束抽象类。
IValidEntry 验证明细接口详解
说明
当我们将 IConstraint 独立出来时，同时有下面的一些问题：
（1）如何指定对应 message
（2）如何指定约束生效条件 condition
（3）如何指定约束的分组信息 group
IValidEntry 接口就是为了解决这些问题，在 IConstraint 的基础之上进行一系列的功能增强。
使用方式
测试代码，参见类ValidBsValidEntryTest
IValidEntry validEntry = ValidEntry.of(JsrConstraints.notNullConstraint ());
IResult result = ValidBs.on(null, validEntry)
.result()
.print();
Assert.assertFalse(result.pass());
message() 自定义提示消息
我们可以自定义改约束条件的提示消息。
final IValidEntry validEntry = ValidEntry.of(JsrConstraints.notNullCons traint())
.message("自定义：指定值不能为空");
IResult result = ValidBs.on(null, validEntry)
.valid()
.result();
Assert.assertEquals("自定义：指定值不能为空", result.notPassList().get(0). message());
group() 分组验证
需求
有时候我们希望只验证某一种分组的约束条件。
测试代码
按照如下方式制定，只有当 ValidEntry 的 group 信息与 ValidBs.group() 符合时，
才会被执行。
final IValidEntry firstEntry = ValidEntry.of(JsrConstraints.sizeConstra int(5, 10))
.group(String.class);
final IValidEntry otherEntry = ValidEntry.of(JsrConstraints.sizeConstra int(3, 20))
.group(Integer.class);
IResult result = ValidBs
.on("12", firstEntry, otherEntry)
框架阶段测试卷 选择题(共50题，每题2分，满分100分) 1．选出不是Restrictions方法的选项（D ）。 A．eq() B．gt() C．like() D．isNULL() 2．已知系统中TBL_USER 表对应的实体类是TblUser，下列HQL 语句中正确的是 （D ）。 A．from Tbl_User B．select * from tbluser C．select TblUser from TblUser D．from TblUser t where t.uname = "15" 3．阅读下面的代码，要输出查询结果中第一条记录的用户名，正确的代码是（AD ）。 String hql = "select u.uname, u.upass from TblUser u"; Query query = session.createQuery(hql); A．Object[] arr = (Object[])query.list().iterator().next(); System.out.println(arr[0]); B．TblUser user = (TblUser)query.list().get(0); System.out.println(user.getUname()); C．String uname = (String)query.list().get(0).get(0); System.out.println(uname); D．String uname = (String)query.list().get(0)[0]; System.out.println(uname); 4．对下面代码中存在的错误，说法不正确的是（D）。 String hql = "from TblUser u where u.status = @status ";//<1> Query query = session.createQuery();//<2> query.setNamedParameter(":status","");//<3> return query.executeQuery(hql);//<4> A．第一行中的命名参数“@status”应该是“:status” B．第二行createQuery 函数应该传入hql 作为参数 C．第三行命名参数名称“:status”应该是“status” D．第四行应该是“return query.list(hql);” 5．下面代码的执行效果是（C ）。 String hql = "from TblStudent s order by s.score asc"; Query query = session.createQuery(hql); query.setFirstResult(0); query.setMaxResults(5); return query.list(); A．返回分数最高的五个学生
Java EE开发四大常用框架 Struts Struts是一个基于Sun J2EE平台的MVC框架，主要是采用Servlet和JSP技术来实现的。 Struts框架可分为以下四个主要部分，其中三个就和MVC模式紧密相关： 1、模型 (Model)，本质上来说在Struts中Model是一个Action类(这个会在后面详细讨论)，开发者通过其实现商业逻辑，同时用户请求通过控制器(Controller)向Action的转发过程是基于由struts-config.xml文件描述的配置信息的。 2、视图(View)，View是由与控制器Servlet配合工作的一整套JSP定制标签库构成，利用她们我们可以快速建立应用系统的界面。 3、控制器(Controller)，本质上是一个Servlet，将客户端请求转发到相应的Action 类。 4、一堆用来做XML文件解析的工具包，Struts是用XML来描述如何自动产生一些JavaBean 的属性的，此外Struts还利用XML来描述在国际化应用中的用户提示信息的(这样一来就实现了应用系统的多语言支持)。 Spring Spring是轻量级的J2EE应用程序框架。 Spring的核心是个轻量级容器(container)，实现了IoC(Inversion of Control)模式的容器，Spring的目标是实现一个全方位的整合框架，在Spring框架下实现多个子框架的组合，这些子框架之间彼此可以独立，也可以使用其它的框架方案加以替代，Spring希望提供one-stop shop的框架整合方案。 Spring不会特別去提出一些子框架来与现有的OpenSource框架竞争，除非它觉得所提出的框架夠新夠好，例如Spring有自己的 MVC框架方案，因为它觉得现有的MVC方案有很多可以改进的地方，但它不强迫您使用它提供的方案，您可以选用您所希望的框架来取代其子框架，例如您仍可以在Spring中整合您的Struts框架。 Spring的核心概念是IoC，IoC的抽象概念是「依赖关系的转移」，像是「高层模组不应该依赖低层模组，而是模组都必须依赖于抽象」是 IoC的一种表现，「实现必须依赖抽象，而不是抽象依赖实现」也是IoC的一种表现，「应用程序不应依赖于容器，而是容器服务于应用程序」也是IoC的一种表现。 Spring的架构性的好处 Spring能有效地组织你的中间层对象,无论你是否选择使用了EJB。如果你仅仅使用了Struts或其他的包含了J2EE特有APIs的framework，你会发现Spring关注了遗留下的问题。 Spring能消除在许多工程上对Singleton的过多使用。根据我的经验，这是一个主要的问题，它减少了系统的可测试性和面向对象特性。 Spring 能消除使用各种各样格式的属性定制文件的需要,在整个应用和工程中，可通过一种一致的方法来进行配置。曾经感到迷惑，一个特定类要查找迷幻般的属性关键字或系统属性,为此不得不读Javadoc乃至源编码吗？有了Spring，你可很简单地看到类的JavaBean 属性。倒置控制的使用(在下面讨论)帮助完成这种简化。Spring能通过接口而不是类促进好的编程习惯，减少编程代价到几乎为零。 Spring被设计为让使用它创建的应用尽可能少的依赖于他的APIs。在Spring应用中的大多数业务对象没有依赖于Spring。 使用Spring构建的应用程序易于单元测试。
在Java开发中，我们经常使用Struts、Hibernate和Spring三个主流框架，但你是否知道这三个框架最初是为解决怎样的问题而生的? Struts、Hibernate和Spring是我们Java开发中的常用关键，他们分别针对不同的应用场景给出最合适的解决方案。但你是否知道，这些知名框架最初是怎样产生的? 我们知道，传统的Java Web应用程序是采用JSP+Servlet+Javabean来实现的，这种模式实现了最基本的MVC分层，使的程序结构分为几层，有负责前台展示的JSP、负责流程逻辑控制的Servlet以及负责数据封装的Javabean。但是这种结构仍然存在问题：如JSP页面中需要使用<%>符号嵌入很多的Java代码，造成页面结构混乱，Servlet和Javabean负责了大量的跳转和运算工作，耦合紧密，程序复用度低等等。 Struts 为了解决这些问题，出现了Struts框架，它是一个完美的MVC实现，它有一个中央控制类(一个Servlet)，针对不同的业务，我们需要一个Action类负责页面跳转和后台逻辑运算，一个或几个JSP页面负责数据的输入和输出显示，还有一个Form类负责传递Action和JSP 中间的数据。JSP中可以使用Struts框架提供的一组标签，就像使用HTML标签一样简单，但是可以完成非常复杂的逻辑。从此JSP页面中不需要出现一行<%%>包围的Java代码了。可是所有的运算逻辑都放在Struts的Action里将使得Action类复用度低和逻辑混乱，所以通常人们会把整个Web应用程序分为三层，Struts负责显示层，它调用业务层完成运算逻辑，业务层再调用持久层完成数据库的读写。 使用JDBC连接来读写数据库，我们最常见的就是打开数据库连接、使用复杂的SQL语句进行读写、关闭连接，获得的数据又需要转换或封装后往外传，这是一个非常烦琐的过程。Hibernate 这时出现了Hibernate框架，它需要你创建一系列的持久化类，每个类的属性都可以简单的看做和一张数据库表的属性一一对应，当然也可以实现关系数据库的各种表件关联的对应。当我们需要相关操作是，不用再关注数据库表。我们不用再去一行行的查询数据库，只需要持久化类就可以完成增删改查的功能。使我们的软件开发真正面向对象，而不是面向混乱的代码。我的感受是，使用Hibernate比JDBC方式减少了80%的编程量。 现在我们有三个层了，可是每层之间的调用是怎样的呢?比如显示层的Struts需要调用一个业务类，就需要new一个业务类出来，然后使用;业务层需要调用持久层的类，也需要new 一个持久层类出来用。通过这种new的方式互相调用就是软件开发中最糟糕设计的体现。简单的说，就是调用者依赖被调用者，它们之间形成了强耦合，如果我想在其他地方复用某个类，则这个类依赖的其他类也需要包含。程序就变得很混乱，每个类互相依赖互相调用，复用度极低。如果一个类做了修改，则依赖它的很多类都会受到牵连。为此，出现Spring 框架。 Spring Spring的作用就是完全解耦类之间的依赖关系，一个类如果要依赖什么，那就是一个接口。至于如何实现这个接口，这都不重要了。只要拿到一个实现了这个接口的类，就可以轻松的通过xml配置文件把实现类注射到调用接口的那个类里。所有类之间的这种依赖关系就完全通过配置文件的方式替代了。所以Spring框架最核心的就是所谓的依赖注射和控制反转。现在的结构是，Struts负责显示层，Hibernate负责持久层，Spring负责中间的业务层，这个结构是目前国内最流行的Java Web应用程序架构了。另外，由于Spring使用的依赖注射以及AOP(面向方面编程)，所以它的这种内部模式非常优秀，以至于Spring自己也实现了一个使用依赖注射的MVC框架，叫做Spring MVC，同时为了很好的处理事物，Spring 集成了Hibernate，使事物管理从Hibernate的持久层提升到了业务层，使用更加方便和强大。
一、选择题（每题2分，共计100分） 1.下面关于AOP的说法错误的是（）。 A．AOP将散落在系统中的“方面”代码集中实现 B．AOP有助于提高系统的可维护性 C．AOP已经表现出了将要替代面向对象的趋势 D．AOP是一种设计模式，Spring提供了一种实现 2.事务隔离级别是由谁实现的？（）。 A．Java应用程序 B．Hibernate C．数据库系统 D．JDBC驱动程序 标准SQL规范： 在数据库操作中，为了有效保证并发读取数据的正确性，提出的事务隔离级别；为了解决更新丢失，脏读，不可重读（包括虚读和幻读）等问题在标准SQL规范中，定义了4个事务隔离级别，分别为未授权读取，也称为读未提交（read uncommitted）；授权读取，也称为读提交（read committed）；可重复读取（repeatable read）；序列化（serializable）. 3.下列哪项不是Spring的依赖注入方式（）。[选两项] A．setter注入 B．getter注入 C．接口注入 D．构造注入 4.在Spring框架中,面向方面编程(AOP)的目标在于( )。 A．编写程序时不用关心其依赖组件的实现 B．将程序中涉及的公用问题集中解决 C．封装JDBC访训数据库的代码,简化数据访训层的得复性代码 D．实现面面的”无刷新”
A．Spring提供了HibernateDaoSupport类来简化Hibernate的使用 B．在Spring配置文件种可以通过Spring提供的LocalSessionFactoryBean,来获得SessionFactory的实例 C．通过集成Spring和Hibernate,用Spring管理程序的依赖关系，将SessionFactory 注入到DataSource中 D．通过Spring,可以在Biz层代码中无需直接实例化DAO类，而是通过注入得到 6.依赖注入说法正确的是（）。 A．依赖注入的目标是在代码之外管理程序组建间的依赖关系 B．依赖注入即是“面向接口”的编程 C．依赖注入是面向对象技术的替代品 D．依赖注入的使用会增大程序的规模 7.关于spring说法错误的是（）。 A．spring是一个轻量级JAVA EE的框架集合 B．spring是“依赖注入”模式的实现 C．使用spring可以实现声明事务 D．spring提供了AOP方式的日志系统8.在Spring 中，配置Hibernate 事务管理器(Hibernate TransactionManager)时，需要 注入的属性名称是( )。 A．dataSource B．sessionFactory C．baseHibernateDao D．transactionProxyFactoryBean 9.下面（）不是Spring AOP中的通知类型。 A．前置通知 B．后置通知 C．代理通知 D．异常通知
最受欢迎的Java框架介绍
17个最受欢迎的Java 框架：优点、缺点 Java 依旧是最受欢迎的编程语言。这里是如今被使用最多的Java 框架第一部分。 在2018年，Java 依旧是世界上最受欢迎的编程语言。它自带一个庞大的生态和全世界超过900万的Java 开发者。虽然Java 不是最简单的语言，但是你不必从零开始写Java 程序。这里有许多杰出的Java 框架可以编写运行在Java虚拟机上的web 和手机应用程序、微服务和REST API。 Java 框架允许你聚焦于你的app的业务逻辑，而不是编写如处理数据库连接或异常处理这样的基础功 能。此外，如果你有一些Java 的经验，你可以更快的开始。这些框架都使用相同的语法并且与相似的 条件、模型和概念工作。 我们前17 的Java 框架基于直到2018年的使用情况并按字母顺序排列展示的。这里是顶级Java 框架的第一部分。 Blade：极小占用的简单应用程序框架 Blade 是一个轻量级、高性能的Java 框架，它允许你用简单的方式快速构建web 应用程序。作者希望用户再一天内了解整个框架。因此，Blade 专注于简洁和优雅。 Blade 框架遵循MVC（模型-视图-控制器）软件设计模式。它有易于理解的设计，并且不依赖其他任何 第三方库或引入太多层。Blade 基于Java 8。Netty web服务器和模板引擎也内置于框架中。它占用极小，源代码总共小于500kb。
用Blade，你可以访问RESTful 风格的路有接口并可以将你的app 作为当作基础Maven 项目部署。Blade 也内置了安全功能。例如，它带有CSRF（跨站点请求伪造）和XSS（跨站点脚本）防御。它是 一个多功能框架，因为它自带插件扩展和webjar 资源的支持。其主站的文档是中文的。但是，它在 Github repo 也有英文文档。 Dropwizard：生产级RESTful Web 服务 Dropwizard 是一个高性能且简单的用于快速开发RESTful Web 服务的Java 框架。它特别适合创建 Java 微服务。 Dropwizard 框架汇集了一些成熟的Java 库，为你提供了快速且无干扰的开发平台。它自带了一个嵌入 式Jetty 服务器、Google Guava、LogBack、Hibernate Validator、Joda Time和许多其他流行的Java 库。此外，Dropwizard 还包含可用于构建RESTful Web 服务的Jersey 和用于处理JSON 的jackson。你可以将Dropwizard 想成一个独立的生态系统，包含了上述所有依赖捆绑为一个单独的包。 如果你选择Dropwizard，你将不必花费大量时间为如配置、监控、日志的辅助功能编写代码。相反， 你可以专注于你的app 的主要业务逻辑并达到最大生产率。这就是为什么Dropwizard 经常被称为操作 友好的Java 框架。如果你之前写过Java 那么入门不会很难；Dropwizard 的文档甚至有一个简单的 Hello World 示例，它可以帮助你完成第一步。 Grails：基于Groovy 的Web 应用程序框架
文章分类: 下面我将为大家总结一下Java部分的框架和开源项目，让您从总的方面对Java部分框架有一定的了解。 Spring Framework【Java开源JEE框架】 Spring是一个解决了许多在J2EE开发中常见的问题的强大框架。Spring提供了管理业务对象的一致方法并且鼓励了注入对接口编程而不是对类编程的良好习惯。Spring的架构基础是基于使用JavaBean属性的InversionofControl 容器。然而，这仅仅是完整图景中的一部分：Spring在使用IoC容器作为构建完关注所有架构层的完整解决方案方面是独一无二的。 Spring提供了唯一的数据访问抽象，包括简单和有效率的JDBC框架，极大的改进了效率并且减少了可能的错误。Spring的数据访问架构还集成了Hibernate和其他O/Rmapping解决方案。Spring还提供了唯一的事务管理抽象，它能够在各种底层事务管理技术，例如JTA或者JDBC事务提供一个一致的编程模型。 Spring提供了一个用标准Java语言编写的AOP框架，它给POJOs提供了声明式的事务管理和其他企业事务--如果你需要--还能实现你自己的aspects。这个框架足够强大，使得应用程序能够抛开EJB的复杂性，同时享受着和传统EJB相关的关键服务。Spring还提供了可以和IoC容器集成的强大而灵活的MVCWeb框架。【SpringIDE：Eclipse 平台下一个辅助开发插件】 WebWork【Java开源Web开发框架】 WebWork是由OpenSymphony组织开发的，致力于组件化和代码重用的拉出式MVC模式J2EEWeb框架。WebWork目前最新版本是，现在的前身是RickardOberg开发的WebWork，但现在WebWork已经被拆分成了Xwork1和WebWork2两个项目。Xwork简洁、灵活功能强大，它是一个标准的Command模式实现，并且完全从web层脱离出来。 Xwork提供了很多核心功能：前端拦截机(interceptor)，运行时表单属性验证，类型转换，强大的表达式语言(OGNL–theObjectGraphNotationLanguage)，IoC(InversionofControl倒置控制)容器等。WebWork2建立在Xwork之上，处理HTTP的响应和请求。WebWork2使用ServletDispatcher将HTTP请求的变成Action(业务层Action类),session(会话)application(应用程序)范围的映射，request请求参数映射。 WebWork2支持多视图表示，视图部分可以使用JSP,Velocity,FreeMarker,JasperReports，XML等。在中添加了对AJAX的支持，这支持是构建在DWR与Dojo这两个框架的基础之上.【EclipseWork：用于WebWork 辅助开发的一个Eclipse插件】 Struts【Java开源Web开发框架】 Struts是一个基于SunJ2EE平台的MVC框架，主要是采用Servlet和JSP技术来实现的。由于Struts能充分满足应用开发的需求，简单易用，敏捷迅速，在过去的一年中颇受关注。Struts把Servlet、JSP、自定义标签?和信息资源(messageresources)整合到一个统一的框架中，开发人员利用其进行开发时不用再自己编码实现全套MVC模式，极大的节省了时间，所以说Struts是一个非常不错的应用框架。【StrutsIDE：用于Struts辅助开发的一个Eclipse插件】Hibernate【Java开源持久层框架?】 Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序实用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。Eclipse平台下的Hibernate辅助开发工具:【HibernateSynchronizer】【MiddlegenIDE】 Quartz【Java开源调度框架】 Quartz是OpenSymphony开源组织在Jobscheduling领域又一个开源项目,它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的日程序表。Jobs 可以做成标准的Java组件或EJBs。Quartz的最新版本为Quartz1.5.0。 Velocity【Java开源模板引擎】 Velocity是一个基于java的模板引擎(templateengine)。它允许任何人仅仅简单的使用模板语言(templatelanguage)来引用由java代码定义的对象。当Velocity应用于web开发时，界面设计人员可以和java程序开发人员同步开发一
Struts Struts是一个基于Sun Java EE平台的MVC框架，主要是采用Servlet和JSP技术来实现的。 Struts框架可分为以下四个主要部分，其中三个就和MVC模式紧密相关： 1、模型（Model），本质上来说在Struts中Model是一个Action类（这个会在后面详细讨论），开发者通过其实现商业逻辑，同时用户请求通过控制器（Controller）向Action的转发过程是基于由struts-config.xml文件描述的配置信息的。 2、视图（View），View是由与控制器Servlet配合工作的一整套JSP定制标签库构成，利用她们我们可以快速建立应用系统的界面。 3、控制器（Controller），本质上是一个Servlet，将客户端请求转发到相应的Action类。 4、一堆用来做XML文件解析的工具包，Struts是用XML来描述如何自动产生一些JavaBean的属性的，此外Struts还利用XML来描述在国际化应用中的用户提示信息的（这样一来就实现了应用系统的多语言支持）。 Spring Spring是轻量级的Java EE应用程序框架。 Spring的核心是个轻量级容器（container），实现了IoC（Inversion of Control）模式的容器，Spring的目标是实现一个全方位的整合框架，在Spring框架下实现多个子框架的组合，这些子框架之间彼此可以独立，也可以使用其它的框架方案加以替代，Spring希望提供one-stop shop的框架整合方案。 Spring不会特別去提出一些子框架来与现有的OpenSource框架竞争，除非它觉得所提出的框架夠新夠好，例如Spring有自己的MVC框架方案，因为它觉得现有的MVC方案有很多可以改进的地方，但它不强迫您使用它提供的方案，您可以选用您所希望的框架来取代其子框架，例如您仍可以在Spring中整合您的Struts框架。 Spring的核心概念是IoC，IoC的抽象概念是「依赖关系的转移」，像是「高层模组不应该依赖低层模组，而是模组都必须依赖于抽象」是IoC的一种表现，「实现必须依赖抽象，而不是抽象依赖实现」也是IoC的一种表现，「应用程序不应依赖于容器，而是容器服务于应用程序」也是IoC的一种表现。 Spring的架构性的好处 Spring能有效地组织你的中间层对象，无论你是否选择使用了EJB。如果你仅仅使用了Struts或其他的包含了Java EE特有APIs的framework，你会发现Spring关注了遗留下的问题。 Spring能消除在许多工程上对Singleton的过多使用。根据我的经验，这是一个主要的问题，它减少了系统的可测试性和面向对象特性。 Spring 能消除使用各种各样格式的属性定制文件的需要，在整个应用和工程中，可通过一种一致的方法来进行配置。曾经感到迷惑，一个特定类要查找迷幻般的属性关键字或系统属性，为此不得不读Javadoc乃至源编码吗？有了Spring，你可很简单地看到类的JavaBean 属性。倒置控制的使用（在下面讨论）帮助完成这种简化。Spring能通过接口而不是类促进好的编程习惯，减少编程代价到几乎为零。 Spring被设计为让使用它创建的应用尽可能少的依赖于他的APIs。在Spring应用中的大多数业务对象没有依赖于Spring。 使用Spring构建的应用程序易于单元测试。 Spring能使EJB的使用成为一个实现选择，而不是应用架构的必然选择。你能选择用POJOs或local EJBs来实现业务接口，却不会影响调用代码。 Spring帮助你解决许多问题而无需使用EJB。Spring能提供一种EJB的替换物，它们适
JAVA中常说的三大框架指：SSH 即：Spring、Struts、Hibernate Spring：功能强大的组件粘合济，能够将你的所有的java功能模块用配置文件的方式组合起来（还让你感觉不到spring的存在）成为一个完成的应用 Struts：不说了，大名鼎鼎的功能强大的MVC架构 Hibernate：强大的ORM工具，然后很方便将数据库记录转化为java的实体实例，将java 的实体实例很容易的保存到数据库中，如果你不需要很复杂的数据库访问，利用它你根本就不用了解数据库的细节 Java工程师（程序员）面试题 Struts,Spring,Hibernate三大框架的面试 1.Hibernate工作原理及为什么要用？原理： 1.读取并解析配置文件 2.读取并解析映射信息，创建SessionFactory 3.打开Session 4.创建事务Transation 5.持久化操作 6.提交事务 7.关闭Session 8.关闭SesstionFactory 为什么要用： 1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。 2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作 3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。 4. hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。2．Hibernate是如何延迟加载? 1. Hibernate2延迟加载实现：a)实体对象 b)集合（Collection） 2. Hibernate3 提供了属性的延迟加载功能当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提高了服务器的性能。 3．Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系) 类与类之间的关系主要体现在表与表之间的关系进行操作，它们都市对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many 4.Struts1流程： 1、客户端浏览器发出HTTP请求。 2、根据web.xml配置，该请求被ActionServlet接收。 3、根据struts-config.xml配置， ActionServlet先将请求中的参数填充到ActionForm中，然后ActionServlet再将请求发送到Action 进行处理。 4、是否验证，需要验证则调用ActionForm的validate方法，验证失败则跳转到input，成功则继续。 5、Action从ActionForm获得数据，调用javabean 中的业务方法处理数据。 6、Action返回ActionForward 对象，跳转到相应JSP页面或Action。 7、返回HTTP响应到客户端浏览器。 MVC设计模式：modal：“模型”也称业务逻辑，是正真完成任务的代码,相当与JavaBeanview：视图，其实就是显示界面，相当于JSPcontroller：控制器，他控制模型和视图的交互过程，相当于servletstruts1是基于MVC设计模式hibernate是基于ORM对象关系映射 5.struts是什么？
J2EE表示层技术JSF JavaServer Faces(JSF)是一种用于构建Web应用程序的新标准Java框 架。它提供了一种以组件为中心来开发Java Web用户界面的方法，从而简化了开发。JavaServer Faces还引起了广大Java/Web开发人员的兴趣。“企业开发人员”和Web设计人员将发现JSF开发可以简单到只需将用户界面(UI)组件拖放到页面上，而“系统开发人员”将发现丰富而强健的JSF API为他 们提供了无与伦比的功能和编程灵活性。JSF还通过将良好构建的模型-视图-控制器(MVC)设计模式集成到它的体系结构中，确保了应用程序具有更高的可维护性。最后，由于JSF是通过Java Community Process(JCP)开发的一种Java标准，因此开发工具供应商完全能够为JavaServer Faces提供易于使用 的、高效的可视化开发环境。 Struts2 Struts2是一个web应用框架。它不是一个Struts的新的发布版本，而是一个 全新的框架。Struts2是第二代基于Model-View-Controller(MVC)模型的web应用框架。Struts2是java企业级web应用的可扩展性的框架。它是WebWork和Struts社区合并后的产物。这一版本的Struts2声称，Struts2 会接近于原先版本Struts，并且会更容易使用。Struts2没有继承struts1的血统，而是继承了webwork的血统。 Struts2和Struts的构建是社区开发模式的最好实践和证明。事实上，第一版 本的Struts设计的第一目标就是使MVC模式应用于web程序设计。在过去10年，Struts在更好的web应用方面所做的工作是值得肯定的。在某些方面，Struts社区注意到这一框架的局限性，但在这个活跃的社区里，自动识别弱点和顽强不屈的精神，使得克服这些弱点是不困难的。在深入学习MVC运行模式并同时引入一些新的建筑学方面的设计理念后，新的Struts2框架结构更清晰，使用更灵活方便。这一新的结构包含应用逻辑的横切面拦截器，基于注释的配置以减少和去除XML形式的配置文件，功能强大的表达式语言，支持可更改、可重用UI组件的基于微MVC的标签库。Struts2有两方面的技术优势，一是所有的Struts2应用程序都是基于client/server HTTP交换协议，The Java Servlet API揭示了Java Servlet只是Java API的一个很小子集，这样我们可以在业务逻辑部分使用功能强大的Java语言进行程序设计。 更多Struts2信息 Struts Struts是一个基于Sun J2EE平台的MVC框架，主要是采用Servlet和JSP技术来实现的。由于Struts能充分满足应用开发的需求，简单易用，敏捷迅速，在过去的一年中颇受关注。
1.Hibernate工作原理及为什么要用？ 工作原理： 1.读取并解析配置文件 2.读取并解析映射信息，创建SessionFactory 3.打开Session 4.创建事务Transation 5.持久化操作 6.提交事务 7.关闭Session 8.关闭SesstionFactory 为什么要用： 1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的 重复性代码。 2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM 实现。他很大程度的简化DAO层的编码工作 3. hibernate使用Java反射机制，而不 是字节码增强程序来实现透明性。 4. hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。 2．Hibernate是如何延迟加载? 1. Hibernate2延迟加载实现：a)实体对象 b)集合（Collection） 2. Hibernate3 提供了属性的延迟加载功能当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟 加载，他节省了服务器的内存开销，从而提高了服务器的性能。 3．Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系) 类与类之间的关系主要体现在表与表之间的关系进行操作，它们都市对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、 one-to-many、many-to-many 4.Struts1流程： 1、客户端浏览器发出HTTP请求。 2、根据web.xml配置，该请求被ActionServlet接收。 3、根据struts-config.xml配置， ActionServlet先将请求中的参数填充到ActionForm中，然后ActionServlet再将请求发送到Action 进行处理。 4、是否验证， 需要验证则调用ActionForm的validate方法，验证失败则跳转到input，成功则继续。 5、Action从ActionForm获得数据，调用javabean 中的业务方法处理数据。 6、Action返回ActionForward对象，跳转到相应JSP页面或Action。 7、返回HTTP响应 到客户端浏览器。
Java框架介绍
二零一五年九月 目录 一技术简介3 1.1 总体介绍3 1.2 Maven介绍3 1.3 Spring MVC介绍4 1.4 Hibernate介绍4 二配置说明5 2.1 web.xml文件5 2.2 applicationContext-resourse.xml文件6 2.3 applicationContext-service.xml文件6 2.4 applicationContext-source.xml文件6 2.5 applicationContext-source.xml文件7 2.6 spring-servlet.xml文件8 2.7 pom.xml文件8 三源代结构9 3.1 整体结构9 3.2 Dao层9 3.3 Service层9 3.4 Controller层9 3.5 其他10 四业务操作流程（重要）11 4.1 操作图示11 4.2 操作实例11 五突出功能15 5.1 权限管理15
一技术简介 1.1 总体介绍 该框架总体使用Maven+SpringMVC+Hibernate。除了可以较好的进行数据交互，框架各层代码比较分明，也更加系统，基础方法都已集成，对于开发者的帮助事半功倍。 1.2 Maven介绍 maven是一个很好的项目管理或者项目构建工具。 首先是maven的“约定优于配置”，即在maven中并不是完全不可以修改的，他们只是一些配置的默认值而已。但是使用者除非必要，并不需要去修改那些约定内容。maven 默认的文件存放结构如下： /项目目录 o pom.xml 用于maven的配置文件 o/src源代码目录 ?/src/main 工程源代码目录 ?/src/main/java 工程java源代码目录 ?/src/main/resource 工程的资源目录 ?/src/main/webapp工程的jsp等前端文件目录 ?/src/test 单元测试目录 ?/src/test/java o/target 输出目录，所有的输出物都存放在这个目录下 ?/target/classes 编译之后的class文件 其次，构建项目或项目开发过程中，项目所有依赖的版本库，比如spring和hibernate相关依赖库，只需要在pom.xml增加配置信息，如果maven仓库中有该依赖文件就直接引用，没有则会从指定地址下载该依赖文件到本地仓库，供项目使用。即对于项目所有的依赖库，可以进行统一管理，不需要分别配置。 最后，maven也可以进行多项目管理，一般来说，maven要求同一个工程的所有子项目都放置到同一个目录下，每一个子目录代表一个项目，所有具体子项目的pom.xml都会继承总项目pom的内容，取值为子项目pom内容优先。
一些java开发系统必用的基础知识 2.1 JavaEE平台 Java EE是J2EE的一个新的叫法。改掉它名字的目的是为了明确J2EE就只是一个Java企业应用程序。Java EE的核心是EJB3.0，它提供了一个更方便的企业应用程序框架。伴随网络和EJB容器概念的诞生，软件应用行业开始担心sun的合作伙伴是否会不断地在Java平台上引入更新的标准框架，这使得软件应用行业的业务核心组件架构不知所措，以及是否需要EJB的声音来显示这种犹豫。 JavaEE（Java Platform Enterprise Edition）[16]是Java2平台下的一种标准，具备高维护性、高移植性、高扩展性与高复用性等优秀特点。JavaEE以面向接口为原则松散耦合，己发展成为包含Applet、JDBC、JSTL、WebServer等诸多实用性技术的标准平台。 2.2 MVC 框架 MVC[17、18]全名是Model View Controller，即模型-视图-控制器。MVC 框架巧妙地把业务逻辑和数据显示分开来，具有高重用性、低耦合性、可维护性高、生命周期成本低、部署快等让许多开发者热衷选择特点。是架构设计过程中的必选框架。 MVC是一种软件设计范式。它通过分离业务逻辑、数据和接口显示来组织代码，并且把业务逻辑收集到一个组件中。它不需要重写业务逻辑，同时改进和定制界面和用户交互。MVC是的开发很独特，它把传统的输入、输出和处理功能映射到一个逻辑图形用户界面结构中。 2.3 SSH 框架 SSH2[19]全称是的缩写，是一个成熟又经典集成框架，是一种轻量级的企业级Java EE平台，具有高实用性和易扩展性，主要职责分为数据持久层、业务逻辑层、视图层和控制层。基于该框架应用可在普通Web容器中运行，无需获得EJB容器的支撑。 SSH框架集是很多软件设计过程中使用的框架集。此框架就是基于MVC模式开发出来的。MVC模式已经成为现代J2EE开发中的一种常见模式，并深受JSP、PHP和其他开发人员的喜爱。MVC模式包括视图、控制器和模型。将应用程序分成这三个部分后，每个部分都处理自己的任务。视图层提取用户的输入信息并将其提交给控制器。控制器根据某些选择决定模型层将处理该请求。模型层用来处理用户的请求，会根据业务逻辑代码来返回数据，到最后会通过视图层来显示给用户看。 2.3.1 Struts2就是基于MVC设计模式的一个网络应用框架，它的本质是一个servlet。在MVC设计模式中，Struts2被用作一个控制器来建立模型和视图之间的数据交互。Struts 2是下一代Struts。它是在struts 1和webwork 技术的基础上开发的一个新的struts 2框架。它的新struts 2架构与struts
JAVA三大框架用来做WEN应用。 struts主要负责表示层的显示 spring利用它的IOC和AOP来处理控制业务（负责对数据库的操作）hibernate主要是数据的持久化到数据库 Struts、Hibernate和Spring是我们Java开发中的常用关键，他们分别针对不同的应用场景给出最合适的解决方案。但你是否知道，这些知名框架最初是怎样产生的? 我们知道，传统的Java Web应用程序是采用JSP+Servlet+Javabean来实现的，这种模式实现了最基本的MVC分层，使的程序结构分为几层，有负责前台展示的JSP、负责流程逻辑控制的Servlet以及负责数据封装的Javabean。但是这种结构仍然存在问题：如JSP页面中需要使用符号嵌入很多的Java代码，造成页面结构混乱，Servlet和Javabean负责了大量的跳转和运算工作，耦合紧密，程序复用度低等等。 Struts 为了解决这些问题，出现了Struts框架，它是一个完美的MVC实现，它有一个中央控制类(一个Servlet)，针对不同的业务，我们需要一个Action类负责页面跳转和后台逻辑运算，一个或几个JSP页面负责数据的输入和输出显示，还有一个Form类负责传递Action和JSP中间的数据。JSP中可以使用Struts框架提供的一组标签，就像使用HTML标签一样简单，但是可以完成非常复杂的逻辑。从此JSP页面中不需要出现一行包围的Java代码了。 可是所有的运算逻辑都放在Struts的Action里将使得Action类复用度低和逻辑混乱，所以通常人们会把整个Web 应用程序分为三层，Struts负责显示层，它调用业务层完成运算逻辑，业务层再调用持久层完成数据库的读写。 使用JDBC连接来读写数据库，我们最常见的就是打开数据库连接、使用复杂的SQL语句进行读写、关闭连接，获得的数据又需要转换或封装后往外传，这是一个非常烦琐的过程。 Hibernate 这时出现了Hibernate框架，它需要你创建一系列的持久化类，每个类的属性都可以简单的看做和一张数据库表的属性一一对应，当然也可以实现关系数据库的各种表件关联的对应。当我们需要相关操作是，不用再关注数据库表。我们不用再去一行行的查询数据库，只需要持久化类就可以完成增删改查的功能。使我们的软件开发真正面向对象，而不是面向混乱的代码。我的感受是，使用Hibernate比JDBC方式减少了80%的编程量。 现在我们有三个层了，可是每层之间的调用是怎样的呢?比如显示层的Struts需要调用一个业务类，就需要new一个业务类出来，然后使用;业务层需要调用持久层的类，也需要new一个持久层类出来用。通过这种new的方式互相调用就是软件开发中最糟糕设计的体现。简单的说，就是调用者依赖被调用者，它们之间形成了强耦合，如果我想在其他地方复用某个类，则这个类依赖的其他类也需要包含。程序就变得很混乱，每个类互相依赖互相调用，复用度极低。如果一个类做了修改，则依赖它的很多类都会受到牵连。为此，出现Spring框架。 Spring Spring的作用就是完全解耦类之间的依赖关系，一个类如果要依赖什么，那就是一个接口。至于如何实现这个接口，这都不重要了。只要拿到一个实现了这个接口的类，就可以轻松的通过xml配置文件把实现类注射到调用接口的那个类里。所有类之间的这种依赖关系就完全通过配置文件的方式替代了。所以Spring框架最核心的就是所谓的依赖注射和控制反转。 现在的结构是，Struts负责显示层，Hibernate负责持久层，Spring负责中间的业务层，这个结构是目前国内最流行的Java Web应用程序架构了。另外，由于Spring使用的依赖注射以及AOP(面向方面编程)，所以它的这种内部模式非常优秀，以至于Spring自己也实现了一个使用依赖注射的MVC框架，叫做Spring MVC，同时为了很好的处理事物，Spring集成了Hibernate，使事物管理从Hibernate的持久层提升到了业务层，使用更加方便和强大。