【教程】java写一个登陆程序，要求用户输入相应的数据进行登录逻辑的判断，如果出现错误使用自定义异常
package com.zuxia.javabasic.
import java.awt.B
import java.awt.C
import java.awt.L
import java.awt.P
import java.awt.TextF
import java.awt.event.ActionE
import java.awt.event.ActionL
import javax.swing.*;
public class LoginTest extends JFrame implements
ActionListener{
&public static void main(String[] args) {
&&new LoginTest();
&//窗体控件
&Panel p = new Panel();
&&//实例化标签
&&Label null1=new Label();
&&Label lblName=new
&&TextField txtName=new
TextField();
&&Label lblPassword=new
&&TextField txtPassword=new
TextField();
&&Label lblError=new
&&Button btnlogin=new
&&Button btnCancel =new
Button();&
&//初始化控件
&&public void initialize(){
&&&//改变p面板的布局为空布局
&&&p.setLayout(null);
&&&lblName.setText("用户名:");
&&&lblName.setBounds(30,10,40,20);
&&&txtName.setBounds(90,10,160,20);
&&&//加载标签
&&&p.add(lblName);
&&&//加载输入文本框
&&&p.add(txtName);
&&&lblPassword.setText("密&&&&
&&&txtPassword.setColumns(15);
&&&txtPassword.setEchoChar('*');
&&&lblPassword.setBounds(30,40,40,20);
&&&txtPassword.setBounds(90,40,160,20);
&&&p.add(lblPassword);
&&&p.add(txtPassword);
&&&btnlogin.setLabel("登录");
&&&btnCancel.setLabel("取消");
&&&btnlogin.setBounds(100,80,
&&&btnCancel.setBounds(180,80,
&&&btnlogin.addActionListener(this);
&&&btnCancel.addActionListener(this);
&&&p.add(btnlogin);
&&&p.add(btnCancel);
&&&lblError.setBounds(60,
130, 180, 20);
&&&lblError.setBackground(Color.red);
&&&p.add(lblError);
&&&lblError.setVisible(false);
&&private void checkUser() throws
ExceptionClass1 {
name& = txtName.getText().trim();
password = txtPassword.getText().trim();
&&&if("jack".equals(name)&&
"jack123".equals(password)) {
&&&&lblError.setVisible(true);
&&&&lblError.setText("欢迎登陆！");
new ExceptionClass1("用户名或密码错误！");
&//构造方法
&public LoginTest(){
&&//设置窗体的大小
&&this.setSize(300, 200);
&&//设置关闭
&&this.setDefaultCloseOperation(3);
&&//设置窗体是否能够放大
&&this.setResizable(false);
&&//设置窗体居中
&&this.setLocationRelativeTo(null);
&&//设置窗体显示
&&this.setVisible(true);
&&//设置标题
&&this.setTitle("欢迎您使用俺的登录界面");
&&//加载面板
&&this.add(p);
&&//初始化控件
&&this.initialize();
&@Override
&public void actionPerformed(ActionEvent e)
&&if(e.getSource()==btnlogin){
&&&&checkUser();
&&&} catch
(ExceptionClass1 e1) {
&&&&lblError.setVisible(true);
lblError.setText(e1.getMessage());
&&if(e.getSource()==btnCancel){
&&&txtName.setText("");
&&&txtPassword.setText("");
class ExceptionClass1 extends Exception{
&public ExceptionClass1() {
&&super();
&public ExceptionClass1(String message){
&&super(message);
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。用户名：polaris1119
文章数：53
评论数：323
访问量：975175
注册日期：
阅读量：1297
阅读量：3317
阅读量：588016
阅读量：474616
51CTO推荐博文
用if、Exception还是assert？
&& & & & &&&看JavaEye论坛帖子：《面试题:用Exception异常还是if判断》的感想
今天在JavaEye上看到一个很火的帖子，题目是：面试题:用Exception异常还是if判断。内容大概是：
&&& 当参数不合法的时候,究竟是if else 判断后返回一个值还是直接来个Exception ?
&&& 如果是 if else 的话,有什么好处 ?
&&& 如果是 exception 的话,又有什么好处 ?
&&& 或者是根据不同情况来定?
实际中应该使用if else或Exception的都有，因而下面的回复也是各抒己见，很多人都有一定的道理。在此先列出几个个人觉得比较靠谱的回复：
1）sam_chi：看情况吧，如果能在方法里面处理不影响方法功能的话使用if else处理，如果参数错误导致方法不能正常工作，那么就得抛异常了,Java提供了java.lang.IllegalArgumentException，可以直接new一个抛出去，这是一个RuntimeException,不需要try..catch。
2）mercyblitz：if-else 方式的好处在于更贴近与逻辑思维，性能优于Exception。相对于Exception，其缺点是，不适合OOP，语义不明显，不易于错误错误跟踪或错误提示较少，并且类型比较单一（比如利用C语言的原生类型）或者难以统一（比如C语言结构和宏定义）。
exception方法的好处在于是业务逻辑和异常处理分离（代码相对清晰），try中处理业务，catch中处理异常情况。在API设计中，可以设计Exception Handler来处理异常，使得层次分明。同时，更好的OOP的封装和多态性。缺点在于性能相对差。
3）fireaap：根据情况来选择使用if...else，还是exception。选择的依据就是，你的方法的职责。也可以说是你方法的契约。
4）konser：sam_chi 说的很对，首先大家要明白什么是异常，异常就是程序不能正常执行，错误的调用api的方法，资源失败等等原因 。程序逻辑又是一回事。为什么要把异常和逻辑判断混合起来做对比？& 补充一下如果,当参数不合法的时候抛出IllegalArgumentException .
如果是 if else 的话,有什么好处 ?
参数不合法程序都不能正常执行了那你说有啥好处?
如果是 exception 的话,又有什么好处 ?
面向对象的思维，抛出每个异常时可根据不同异常以不同方式进行处理 。缺点是创建消耗内存，效率低。
5）IcedCoffee：java规范的定义是说异常不要参与控制流程，你不能把异常作为一种正常的控制流程作为程序的一部分，这样是不对的.
面试官正真要考的就是这个..
没有哪个公司会用异常来处理参数验证..
6）liupopo：先要明确异常是做什么的，异常是程序执行时的一些非正常的情况，如果有不正确的数据、逻辑等会抛出异常。
if else是逻辑判断，控制程序流程。
断言是预先决断应该是什么样的值，不应该是什么类型等明确的条件
从定义上不太好区分这些怎么去用，但可以从使用场景去考虑，下面的可能不十分准确，但大家可以参考一下：
异常：是程序员写给其他程序员的，比方说我写了一个方法，如果其他人使用我这个方法的时候有可能不按我想的路子使用，可能会引起我的方法产生不正常的处理，这时候我要使用异常，而且可以决定产生异常了是由我这个方法本身进行处理(catch语句中处理)还是交给调用者进行处理(直接把异常抛出)
if else 就是我写的方法，要进行逻辑判断，就用它，没什么好说的吧。
断言可用处大了，是我在调用别人写的方法，或者我处理程序时对通过其他途径得到的数据(如调用别人方法的返回值(好象不建议用断言)，通过参数传入的值)等进行假设它就是某值时使用的。是方便开发、调试提供的一个语法元素
7）JonyUabka：1对可预见的运行时异常当进行捕捉并处理，比如空指针等。通常，对空指针的判断不是使用捕捉NullPointException的方式，而是在调用该对象之前使用判断语句进行直接判断，如：
//若不对list是否为null进行检查，则在其为null时会抛出空指针异常
if(null != list && 0 & list.size()){
for(int i = 0; i & list.size(); i++){
2对于经常发生的可预计事件不要采用异常
3不要使用异常实现控制结构。
4通常的思想是只对错误采用异常处理：逻辑和编程错误，设置错误，被破坏的数据，资源耗尽，等等。
对于java的编码规范，有具体描述。我想考官希望得到的是这个方向的答案。
8）maomaolingyu：
A 逻辑自己控制，清晰
A 当情况复杂时 需要过多的if else .导致逻辑难以理解
B 容易存在漏洞，导致错误或者不期望的结果
A 异常通过异常链传播且会被jvm自动捕捉，减少逻辑代码
B 异常很容易确定代码问题段，方便测试
A 当异常发生但是没有正确捕获时,会异常抛出到用户页面.
引用了这么多，下面谈谈本人的一点看法，不对之处敬请指正。
首先，对于这个问题，不应该回答：用Exception异常或者if判断，而应该视情况决定使用Exception还是if。个人觉得面试官比较看重的是你对异常的理解，回答的关键应该是两者的优缺点与适用场合上，顺带可以总结一些实际中你是如何处理异常的。对于有人说使用断言(assert)，还说是标准答案，本人实在不赞同。就像有人回答说：题目问的是：用Exception异常还是if判断，却来个用断言，太离题了吧。而且这么回答的话，下面的问题怎么答？难道直接说他们都不好，assert好？
本人觉得liupopo说的靠谱。下面结合一些代码来说明一些问题。
在此之前，就像不少人说的一样，先要明确什么是Exception。《The Java Language Specification 3.0》中有这么一句描述：When a program violates the semantic constraints of the Java programming language, the Java virtual machine signals this error to the program as an exception.大意是：当程序违反Java语言的语义约束时，Java虚拟机会将这个错误（异常）发送给程序。
下面进入正题：
1、看Java API如何处理的
本人查看了DateFormat、Integer等类的源码，分析如下：
1.1 public final String format(Date date)方法
该方法的参数date只有一种情况是不正确的：null。然而，阅读源码发现并没有判断该参数是否为null。那么当为null时（违反了Java语言的语义），异常NullPointerException自然而然是JVM自动抛出的，而不是API通过throw抛出的。
1.2 public static Integer valueOf(String s, int radix) throws NumberFormatException方法
该方法有两个参数，第一个String类型的参数有可能为null，而方法声明抛出NumberFormatException异常，因而有一段if判断：
&&&&&&& if (s == null) {
&&&&&&&&&&& throw new NumberFormatException(&null&);
对于radix参数有不少限制，因而源码中进行了几个if判断：
&&&&&&& if (radix & Character.MIN_RADIX) {
&&&&&&&&&&& throw new NumberFormatException(&radix & + radix +
&&&&&&&&&&&&&&&&&&&&&&&&&&& & less than Character.MIN_RADIX&);
&&&&&&& if (radix & Character.MAX_RADIX) {
&&&&&&&&&&& throw new NumberFormatException(&radix & + radix +
&&&&&&&&&&&&&&&&&&&&&&&&&&& & greater than Character.MAX_RADIX&);
后面还有几个其他的判断。
总结：在论坛中，有人提到在JDK源码中，经常可以看见类似
&&&&&&& if (s == null) {
&&&&&&&&&&& throw new NumberFormatException(&null&);
这样的代码。借用liupopo的话，JDK中的方法是写给Java程序员调用的，而且Java有自己内部的一套异常机制。比如，对于format()方法抛出的NullPointerException异常，JDK不可能自己进行处理，出现该异常是：这个方法的时候没按它的路子使用，我们要使用该方法就应该确保传入的Date参数不是null，即需要进行if判断，对于valueOf方法一样如此，调用方法前就应该对是否为null值进行if判断（或确保非null）。从JDK的处理radix参数的方法我们可以看出，if经常与Exception结合使用，if用于处理逻辑，Exception用于告诉用户&有问题&。所以，如果你写的代码是给其他人使用的，你需要考虑是否抛出异常，这个时候对于参数的判断更多的应该使用JDK这种方式：对于非法参数，if判断后，包装为统一的Exception抛出，当然异常也有可能没必要抛出，而是自己处理（各种开源框架中都有这样情况）。
2、现在推荐的Java异常机制
Java API在设计的时候大量使用了checked exception，当时很推荐这种方式。然而，用过Spring的人都知道，Spring中大量使用了unchecked exception即RuntimeException。《thinking in java》的作者Bruce Echel说：&当少量代码时，checked异常无疑是十分优雅的构思，并有助于避免了许多潜在的错误。但是经验表明，对大量代码来说结果正好相反&。很多时候对于Java API抛出的异常，程序员都不知道怎么处理，比如SQLException，大家无非就是catch，然后e.printStackTrace()，或者什么也不做，这样导致程序中很多的try...catch...，既然如此，那么抛出checked exception就没有必要了，而且抛出uncheck exception不会污染接口。对于异常处理的问题很是有必要研究研究的。
既然推荐使用uncheck exception，结合Exception本身的特点，在写应用程序（不是提供给其他开发人员的API）时，参数的判断应该更多的使用if，毕竟参数错误的情况不会很多。
另外，有人建议使用Java自己的IllegalArgumentException异常进行判断，当然这有时候也是可行的。比如，有些时候参数没法活很难通过if来判断（因为我们不知道非法参数会是什么），这个时候可以使用该异常。
其实，很多时候，对参数合法性检查时，需要考虑方法的返回值。比如，接收一个Date类型参数，然后返回一个对应的String类型在页面上显示（该参数不是必须的，比如生日），这个时候，如果Date类型参数为null，我们不应该抛出NullPointerException，而应该用if进行如下判断：
&&&&&&& if(date==null) {
&&&&&&&&&&& return &&;
返回空字符串很合理，这样页面就会显示空白（相当于没填）。其他情况，如返回值为boolean类型，很可能参数非法时会返回false。视具体情况而定。
3、关于断言(assert)
论坛回复中有人力推assert来判断参数合法性。不知道是没有理解题目的意思还是对断言本身不够了解，亦或对断言情有独钟。对于该面试题，可以肯定的是，用断言(assert)绝对是错误的。断言只是程序员测试和调试的一个工具，发布后一般也不会开启的，而且，Java规范也建议这么做。而参数是否合法性却总是存在的，所以用断言是完全错误的。
关于Java的assert，本人几乎没使用过，也很少见人使用。对程序进行测试或调试，更多的是使用JUnit或IDE的Debug功能，他们已经工作的很好了。在网上找到一篇很有意思的文章，他是痛批java的assert（），感兴趣的可以读读。个人不完全同意其观点，Java引入assert应该有其好处。
在这里把《The Java Language Specification 3.0》中对assert的描述做个总结。
3.1 assert的语法
assert语句有两种形式语法：
&&& assert 表达式1 ;
&&& assert 表达式1 : 表达式2 ;
其中，表达式1的值必须是boolean类型，否则会编译错误。这里boolean类型有两种形式：1）var1==var2；2）var=true。其中第二种形式var是boolean类型，一般应该使用第一种形式，而第二种形式往往是程序员失误造成的。表达式2的值可以是除了void之外的任何类型。
3.2 断言开启时机
默认情况下断言没有开启。可以选择在哪个类上启用断言（断言启用没有继承性）。在类字段初始化器和静态初始化器初始化之前，类的类装载器根据配置决定启用或禁用断言。一旦类初始化完成后，断言的状态（启用或禁用）没法再改变。
然而，在规范中提到了一种例外情况：类层次结构之间的循环情况（实际中几乎不会这么做）。例子程序如下：
&&&&&&& public class Foo {
&&&&&&&&&&& public static void main(String[] args) {
&&&&&&&&&&&&&&& Baz.testAsserts();
&&&&&&&&&&&&&&& // Will execute after Baz is initialized.
&&&&&&&&&&& }
&&&&&&& class Bar {
&&&&&&&&&&& static {
&&&&&&&&&&&&&&& Baz.testAsserts();
&&&&&&&&&&&&&&& // Will execute before Baz is initialized!
&&&&&&&&&&& }
&&&&&&& class Baz extends Bar {
&&&&&&&&&&& static void testAsserts() {
&&&&&&&&&&&&&&& boolean enabled =
&&&&&&&&&&&&&&& assert enabled =
&&&&&&&&&&&&&&& System.out.println(&Asserts & + (enabled ? &enabled& : &disabled&));
&&&&&&&&&&& }
调试运行会发现，在assert没有开启的情况下，第一次输出的结果却显示assert已开启，当然第二条语句显示没有开启（注意，如果assert没开启，assert enabled = true这条语句是没有效果的）。这是说明，当断言语句在类初始化之前执行时，结果就如同开启了assert。（Polaris在调试时，发现一个奇怪的现象：就是第一次执行testAsserts方法时，单步调试，assert enabled =语句似乎跳过去了，不过结果却显示该语句是执行了的。很奇怪。）
关于断言的开启方法，控制台开启，IDE开启可以上网搜索，在此不介绍。
3.3 使用断言的注意事项
Java规范中对于断言语句的执行有详细的说明，有兴趣的朋友可以参阅
关于assert抛出的AssertionError，规范上建议不要捕获。
由于断言有可能没有开启，因而程序千万不要假定断言中的表达式会被计算，即不能依赖断言的结算结果（表达式1的值），所以，表达式1可能会产生一定的副作用：
1）assert语句虽然可以有副作用，如上面提到的表达式1返回boolean类型的第二种形式，然而这通常是不合适的，因为这可能导致依赖此值的程序在assert启用或禁用时有不同结果；
2）不要使用断言作为公共方法的参数检查，公共方法的参数永远都要执行。这一点可以很好的解释为什么说使用断言来判断参数合法性是错误的，尽管断言有时候可以用于检查传递给私有方法的参数。
Java规范在讲解断言副作用时，还说到了erroneous arguments should result in an appropriate runtime exception (such as IllegalArgumentException, IndexOutOfBoundsException or NullPointerException)，即错误的参数检查应该产生一个合适的运行时异常。
在网上看到有总结使用断言的情况：（列举出来供参考）
1）可以在预计正常情况下程序不会到达的地方放置断言 ：assert false&
2）断言可以用于检查传递给私有方法的参数。（对于公有方法，因为是提供给外部的接口，所以必须在方法中有相应的参数检验才能保证代码的健壮性）&
3）使用断言测试方法执行的前置条件和后置条件
4）使用断言检查类的不变状态，确保任何情况下，某个变量的状态必须满足。（如age属性应大于0小于某个合适值）
3.4 Polaris的建议
要进行调试或测试，可以使用IDE或JUnit。
说了这么多希望对大家有个参考作用，同时不对之处敬请批评指正。本文出自 “” 博客，请务必保留此出处
了这篇文章
类别：┆阅读(0)┆评论(0)
09:30:35 15:23:06Java语言如何进行异常处理，关键字：throws、throw、try、catch、finally分别如何使用？ - CSDN博客
Java语言如何进行异常处理，关键字：throws、throw、try、catch、finally分别如何使用？
需要学习资料的+微信公众号 学习资源后台找我
本人比较忙 我看到了会在后台帮你，谢谢关注啦
Java通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。
在Java中，每个异常都是一个对象，它是Throwable类或其子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并可以对其进行处理。
Java的异常处理是通过5个关键词来实现的：try、catch、throw、throws和finally。一般情况下是用try来执行一段程序，如果系统会抛出（throw）一个异常对象，可以通过它的类型来捕获（catch）它，或通过总是执行代码块（finally）来处理；try用来指定一块预防所有异常的程序；
catch子句紧跟在try块后面，用来指定你想要捕获的异常的类型；
throw语句用来明确地抛出一个异常；
throws用来声明一个方法可能抛出的各种异常（当然声明异常时允许无病呻吟）；
finally为确保一段代码不管发生什么异常状况都要被执行；
本文已收录于以下专栏：
相关文章推荐
Java通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的
接口。在Java中，每个异常都是一个对象，它是Throwable类或其它子类的实例。当一
个方法出现异常后...
使用Java异常的人很多，但能合理使用的却不多，Java异常处理设计是一个冷门的话题，但好的异常设计会让程序有质的变化，所以本文从各个方面分析便总结了，在Java程序中，如何进行异常设计。...
try块表示程序正常的业务执行代码。如果程序在执行try块的代码时出现了“非预期”情况，JVM将会生成一个异常对象，这个异常对象将会被后面相应的catch块捕获。
catch块表示一个异常捕获块。当...
Java通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。
在Java中，每个异常都是一个对象，它是Throwable类或其它子类的实例。当一个方法出现异常后便
Java通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。在Java中，每个异常都是一个对象，它是Throwable类或其它子类的实例。当一个方法出现异常后便抛出一个异常对...
如果在一个方法内部出现了异常（或者在方法内部调用的其他方法抛出了异常），这个方法将在抛出异常的过程中结束。
异常处理理论上有两种基本模型。终止模型和恢复模型。个人理...
Java的异常处理的五个关键字, try、catch、finally、throw、throws 的关系：
一个方法在声明时可以使用throws声明抛出所要产生的若干个异常，并在该方法的方法体中具...
Java 通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并
提供了良好的接口。在 Java 中，每个异常都是一个对象，它是 Throwable 类或
其它子类的实例。当一个方...
C++ 关键字 (try-finally)
catch 关键字
catch 关键字用来在 try-catch 或 try-catch-finally 语句中定义异常处理块。
他的最新文章
讲师：董岩
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)概述：在java开发时，由于分层的原因（表现层-控制层-业务层-数据持久层），有时候需要对传入的Javabean进行校验，如果过多的校验会导致比较繁琐，做重复的工作，下面将介绍Bean Validation技术，该技术是利用注解的方式，在javabean代码内部，利用注解实现校验，这样会将繁琐的工作变得简单。
注：在阅读如下知识之前，要对注解有一些了解。
来一个简单的Bean Validation实现 ，热热身：
import java.util.S
import javax.validation.ConstraintV
import javax.validation.V
import javax.validation.V
import javax.validation.ValidatorF
import javax.validation.constraints.NotN
import javax.xml.bind.ValidationE
public class Test1 {
public static void main(String [] args ){
Person person = new Person();
Test1.validate(person);
} catch (ValidationException e) {
System.out.println(e.getMessage());
public static &T&
void validate(T t) throws ValidationException {
ValidatorFactory vFactory = Validation.buildDefaultValidatorFactory();
Validator validator = vFactory.getValidator();
Set&ConstraintViolation&T&& set =
validator.validate(t);
if(set.size()&0){
StringBuilder validateError = new StringBuilder();
for(ConstraintViolation&T& val : set){
validateError.append(val.getMessage());
throw new ValidationException(validateError.toString());
class Person{
@NotNull(message="用户名不能为空")
public String getUsername() {
public void setUsername(String username) {
this.username =
上面的代码用到了@NotNull（）注解进行校验，一个完整的校验步骤包括如下四个步骤：
1.约束注解的定义
2.约束验证规则（约束验证器）
3.约束注解的声明
4.约束验证流程
下面用代码来进行详细的解释：
1.约束的定义:
Bean Vlidation技术提供了一些内置的约束定义，还可以自定义；下面是内置的：
约束注解名称约束注解说明
验证对象是否为空
验证对象是否为非空
@AssertTrue
验证 Boolean 对象是否为 true
@AssertFalse
验证 Boolean 对象是否为 false
验证 Number 和 String 对象是否大等于指定的值
验证 Number 和 String 对象是否小等于指定的值
@DecimalMin
验证 Number 和 String 对象是否大等于指定的值，小数存在精度
@DecimalMax
验证 Number 和 String 对象是否小等于指定的值，小数存在精度
验证对象（Array,Collection,Map,String）长度是否在给定的范围之内
验证 Number 和 String 的构成是否合法
验证 Date 和 Calendar 对象是否在当前时间之前
验证 Date 和 Calendar 对象是否在当前时间之后
验证 String 对象是否符合正则表达式的规则
自定义约束的结构如下（其实就是注解的定义）：
@Target({ })
@Retention()
@Constraint(validatedBy ={})
public @interface ConstraintName{
String message() default " ";
Class&?&[] groups() default { };
Class&? extends Payload&[] payload() default { };
可以遵循这个格式，去写自己定义的注解（下面有自定义的例子）
2.约束验证规则（约束验证器）
上面的内容是定义约束，当约束定义好了之后，就需要定义一个约束校验规则，其实就是一个校验器。每一个约束定义要对应一个约束校验器。定义约束校验器必须要实现如下的接口：
public interface ConstraintValidator&A extends Annotation, T& {
void initialize(A constraintAnnotation);
boolean isValid(T value, ConstraintValidatorContext context);
下面会有具体的实现约束校验器
3.约束的声明
声明，其实就是讲自定义的注解或者是内置的注解声明在需要校验的字段/方法等上面，该步骤比较简单，如：
@NumberVlidator(message= "体重必须为数字")
4.验证流程
在实际使用中调用 Validator.validate(JavaBeanInstance) 方法后，Bean Validation 会查找在 JavaBeanInstance上所有的约束声明，对每一个约束调用对应的约束验证器进行验证，最后的结果由约束验证器的 isValid 方法产生，如果该方法返回 true，则约束验证成功，否则验证失败。验证失败的约束将产生约束违规对象（ConstraintViolation 的实例）并放到约束违规列表中。验证完成后所有的验证失败信息均能在该列表中查找并输出
public static &T& void validate(T t) throws ValidationException{
ValidatorFactory vf = Validation.buildDefaultValidatorFactory();
validator = vf.getValidator();
Set&ConstraintViolation&T&& set =
validator.validate(t);
if(set.size()&0){
StringBuilder validateError = new StringBuilder();
for(ConstraintViolation&T& val : set){
validateError.append(val.getMessage() + " ;");
throw new ValidationException(validateError.toString());
至此，一个完整的Bean Validation校验已经完成，是不是很简单，如果还是看不懂的话，下面直接上代码，相信看了代码都会明白的，嘿嘿
完整的Demo
1.一个javabean对象
package validation.
import java.util.D
import javax.validation.constraints.NotN
import javax.validation.constraints.S
import validation.validate.NumberV
public class Person {
@NotNull(message = "用户ID不能为空")
@NotNull(message = "test不能为空")
@NumberVlidator(message= "体重必须为数字")
@NotNull(message = "用户姓名不能为空dd")
@Size(min=1, max=10, message="用户姓名必须是1-10位之间")
2.约束的定义（上面有一个自定义的@NumberVlidator 注解）
package validation.
import java.lang.annotation.D
import java.lang.annotation.ElementT
import java.lang.annotation.R
import java.lang.annotation.RetentionP
import java.lang.annotation.T
import javax.validation.C
import javax.validation.P
@Target({ElementType.ANNOTATION_TYPE,ElementType.METHOD,ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Constraint(validatedBy = {NumberVlidatorImpl.class})
public @interface NumberVlidator {
boolean isNumber () default false;
String message() default "该值应该为数字";
Class&?&[] groups() default { };
Class&? extends Payload&[] payload() default { };
3.对上一步的自定义约束进行实现校验规则（校验器）
package validation.
import java.math.BigD
import javax.validation.ConstraintV
import javax.validation.ConstraintValidatorC
public class NumberVlidatorImpl implements ConstraintValidator&NumberVlidator, String& {
private boolean isN
public void initialize(NumberVlidator constraintAnnotation) {
isNumber = constraintAnnotation.isNumber();
public boolean isValid(String value, ConstraintValidatorContext context) {
if(value==null || value.length()&=0){
return true;
if(isNumber){
Long.parseLong(value);
new BigDecimal(value);
return true;
} catch (NumberFormatException e) {
return false;
4.具体的校验实现（校验工具）
package validation.
import java.util.S
import javax.validation.ConstraintV
import javax.validation.V
import javax.validation.V
import javax.validation.ValidatorF
import javax.xml.bind.ValidationE
public class VlidationUtil {
private static V
ValidatorFactory vf = Validation.buildDefaultValidatorFactory();
validator = vf.getValidator();
public static &T& void validate(T t) throws ValidationException{
Set&ConstraintViolation&T&& set =
validator.validate(t);
if(set.size()&0){
StringBuilder validateError = new StringBuilder();
for(ConstraintViolation&T& val : set){
validateError.append(val.getMessage() + " ;");
throw new ValidationException(validateError.toString());
5.注意： 以上的需要依赖其他的类库，下面是maven的依赖（该步骤不能忘记哦）
javax.validation
validation-api
1.1.0.Final
org.ow2.util.bundles
hibernate-validator-4.3.1.Final
import javax.xml.bind.ValidationE
import validation.util.VlidationU
import validation.vo.P
public class Test1 {
public static void main(String [] args ){
Person person = new Person();
VlidationUtil.validate(person);
} catch (ValidationException e) {
System.out.println(e.getMessage());
OK，整个流程结束！
总结：Bean Validation技术除了可以校验一般的数据类型，还支持校验复杂的对象类型，组合类型、等，具体的自行查阅相关资料吧，一般的需求都可以满足的！
最后附加上上面展示的源码，将文件解压缩，执行 mvn eclipse:eclipse 导入到eclipse中运行吧！！
下载次数: 9
浏览: 508132 次
百度网盘的挂了吧???
UfgovDBUtil 是什么类
帮大忙了，非常感谢
十分感谢作者无私的分享，仔细阅读后很多地方得以解惑。
你再客户端搞这么多拦截器干什么
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'