java入门-W2

Posted 码上奉先

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java入门-W2相关的知识，希望对你有一定的参考价值。

一. 输入输出

  • 输入的作用，就是由使用者告诉程序要操作的数据
    • 例如，我要通过饿了么订餐，你得告诉程序你要吃什么，送货地址是什么吧
  • 输出的作用，就是由程序向使用者展现执行的结果
    • 还是订餐的例子，程序向你展示骑手接单没有，送到哪里了
  • 将来输入输出来源会有多种，比如 app，网页，终端程序等等

1. System.out

之前已经介绍过【标准输出】：System.out

打开 jshell 用一下，回忆下对象和方法使用格式

对象.方法(参数);

套用一下，对象是 System.out，方法是 println，参数是 “你好”

jshell> System.out.println("你好");
你好

小技巧

  • jshell 中用 Tab 键可以提示对象有哪些方法
  • jshell 中省略 ; 也不会报错

2. System.in

再来看看输入，对象是 System.in，方法叫 read，没有参数

jshell> System.in.read();

运行后，可以看到光标一闪一闪，表示正在等待用户的输入，这时输入小 a

jshell> System.in.read();
a
$1 ==> 97

  • 会显示 97，称之为返回值，代表 read() 读入的结果

    • 因为计算机中所有符号，都是用数字表示，参看下表

  • 前面的 $1 是一个【变量】，将来它就代表 97，也就是刚才输入的小 a

  • 【变量】可以反复被使用

\\00010203040506070809101112131415
0000无无无无无无无无无无无无无无无无
0016无无无无无无无无无无无无无无无无
0032!"#$%&’()*+,-./
00480123456789:;<=>?
0064@ABCDEFGHIJKLMNO
0080PQRSTUVWXYZ[\\]^_
0096`abcdefghijklmno
0112pqrstuvwxyz|~无

System.in 的缺点

  1. 字符被转成的数字，不便人类阅读
  2. 只能输入一个字符

3. Scanner

用 Scanner 改进，System.in 是 java 为我们提供好的对象，而 Scanner 需要我们自己创建，语法是

jshell> new Scanner(System.in);
$2 ==> java.util.Scanner...

将来这个 $2 就代表刚才的 Scanner 对象，我们称之为【变量】

Scanner 对象里面最常用的方法是 nextLine，用法如下

jshell> $2.nextLine();
你好啊
$3 ==> "你好啊"

4. 变量名

$2，$3 这样作为变量名虽然也可以，但如果用更有意义的名称来表示，更方便人类阅读、记忆。例如

jshell> var scanner = new Scanner(System.in)
scanner ==> java.util.Scanner[delimiters=\\pjavaWhitespace+] ... \\E][infinity string=\\Q∞\\E]

jshell> var line = scanner.nextLine()
hello
line ==> "hello"
  • scanner 就代指输入对象
  • line 就代指用 nextLine() 读取到的字符串值
  • var 是关键字，代表某种类型，具体有哪些类型后面再展开

5. 关键字

变量取名时要注意两个规则，不能以数字开头，不能是关键字

什么是关键字呢？关键字就是 java 中有特殊意义的单词，例如见过的有 class，var，new 等等，如果用 idea 中可以通过特殊颜色强调哪些单词是关键字，可以看到这些蓝色的单词都属于关键字

至java 17 为止，共有 67 个关键字，参看这两份表格，这些关键字，都会在今后的课程中陆续学到

二. 类型、变量、运算符

1. 字符与字符串

字符值与字符串值

像这样用双引号引起来的值，在 Java 里称为字符串，字符串顾名思义，由多个字符组成，单个字符用单引号表示，例如

jshell> 'a'
$4 ==> 'a'

jshell> "abc"
$5 ==> "abc"
  • 单引号里必须由一个字符
  • 双引号里可以有零个、一个、多个字符

转义字符

比如我需要输出一个单引号字符值，''' 这样写行不行？本意是想表示中间的单引号，但遗憾的是java把前两个单引号当成了一对，把它当作了那个空字符了

怎么办呢

为了把真正的单引号跟语法的单引号区分开，需要给它加一个反斜杠标记，告诉java，我想表示真正的单引号，而不是语法中的单引号。试一下。

jshell> System.out.println("\\'")
'

这种结合了反斜杠的具有特殊含义的字符，称之为转义字符（Escape Character）

常见的有七个：\\' \\" \\\\ \\n \\t \\b \\r 刚才已经讲过单引号转义了

继续来看几个例子

jshell> System.out.println("\\"") // 双引号转义
"

jshell> System.out.println("\\\\") // 反斜杠本身转义
\\

jshell> System.out.println("1\\n2") // 换行
1
2

jshell> System.out.println("123\\t4") // 缩进
123     4

jshell> System.out.println("123\\b4") // 退格
124

jshell> System.out.println("123\\r4") // 回车，退格是光标退一格，回车是退到头
423

文本块

最后再再来看看文本块，如果有一段文字内，其中需要有很多的转义字符，那么可读性会变得很差，例如

jshell> System.out.println("床前\\"明月\\"光，\\n疑是地上霜。")

因此在 java 14 这个版本引入了文本块来进行改善。

jshell> System.out.println("""
                           床前"明月"光，
                           疑是地上霜。""")

文本块本质上还是属于字符串值，由一对 三个双引号作为起始和结束标记，中间如果想表示双引号、换行这两个特殊字符，无需再转义表示

  • 一个注意事项是 “”" 后需要换个行，不要紧接着写字符。

2. 类型

何为类型

现在让用户输入两个数，求得相加结果

jshell> scanner.nextLine()
1
$22 ==> "1"

jshell> scanner.nextLine()
2
$23 ==> "2"

jshell> $22 + $23
$24 ==> "12"

显然，这并不是我们想要的结果，它是输入的值当作了字符串，+ 号执行的是字符串连接操作，解决办法如下

jshell> scanner.nextInt()
1
$25 ==> 1

jshell> scanner.nextInt()
2
$26 ==> 2

jshell> $25 + $26
$27 ==> 3

nextLine() 和 nextInt() 返回的类型是不同的

  • 前者返回的是字符串，类型为 String，+ 表示两个字符串连接
  • 后者返回的是整数，类型为 int，+ 表示两个整数相加

数字类型

类型名说明数字范围类型后缀
byte整数类型，用1个字节表示 [ − 2 7 , 2 7 ) [-2^7,2^7) [−27,27) 即 [ − 128 , 128 ) [-128,128) [−128,128)
short整数类型，用2个字节表示 [ − 2 15 , 2 15 ) [-2^15,2^15) [−215,215)
int整数类型，用4个字节表示 [ − 2 31 , 2 31 ) [-2^31,2^31) [−231,231)
long整数类型，用8个字节表示 [ − 2 63 , 2 63 ) [-2^63,2^63) [−263,263)L
float浮点小数，用4个字节表示 [ − 1.9999999 ∗ 2 127 , 1.9999999 ∗ 2 127 ] [-1.9999999 * 2^127,1.9999999 * 2^127] [−1.9999999∗2127,1.9999999∗2127]F
double浮点小数，用8个字节表示 [ − 1.9999999 ∗ 2 1023 , 1.9999999 ∗ 2 1023 ] [-1.9999999 * 2^1023,1.9999999 * 2^1023] [−1.9999999∗21023,1.9999999∗21023]D

  • [] 包含等于，() 不包含等于

  • 类型后缀

    • 不区分大小写，但建议用大写，因为小写的 L 与 1 容易混淆
    • 尾符号 D 可以省略

  • float 和 double 精度不同，即小数点后的位数

    • float 的精度二进制是 23，换算成十进制是 6~7
    • double 的精度二进制是 52，换算成十进制是 15~16

字符类型

类型名说明范围
char字符类型，配合单引号 [ 0 , 2 16 ) [0,2^16) [0,216) 即 [ 0 , 65536 ) [0, 65536) [0,65536)
String字符串类型，配合双引号或文本块-

3. 变量与运算符

变量

变量的定义格式为

类型 变量名 = 值;
  • 从语法可以看到，变量由类型和名称组成，类型决定了变量能存储的数据大小与数据格式，名字用来代表后面的值
  • 这个语法其实咱们前面见过类似的，var scanner = new Scanner(System.in)，这里 var 是类型，因为之前我们还没有学习具体有哪些类型，因此使用了 var 来代表某种类型，scanner是变量名，后面这一串就是值，也是 Scanner 对象

= 称之为赋值运算符，可以用来更新变量代表的值。

例如：

int a = 10

这行代码的意思是，定义了整型变量a，更新它的初始值为10

再来一句：

a = 20

这时候为啥不用写前面的类型了呢，因为变量定义只需一次，定义好之后变量就可以反复使用了，这行代码的意思是，将 a 所代表的值更新为 20

变量可以用来保存运算的结果，它自身也能参与运算

运算符

int a = 5 + 3

结果为 8

int a = 5 - 3

结果为 2

int a = 5 * 3

结果为 15

int a = 5 / 3

结果为 1，整数除法有两个注意点

  • 整数除法，只会保留商，而小数部分会被舍弃，并不考虑四舍五入
  • 除0是不合法的，会出错
int a = 5 % 3

结果为 2

小数加减乘除与整数类似，只是小数除法可以保留小数点后的数字，而且可以除零，例如

jshell> 5.0 / 3.0
$40 ==> 1.6666666666666667

jshell> 5.0 / 0.0
$41 ==> Infinity

增强赋值运算符

int a = 20; 
a = a + 10;

意思是，获取 a 的原有值 20，执行加 10 运算，将新的结果重新赋值给 a，a 代表的值被更新成了 30。可以用 += 增强赋值运算符达到类似的效果

a += 10;

先不要看 = 号，获取 a 的原有值 30，执行加 10 运算，运算的结果 40 赋值给 a

a -= 10;

先拿 a 的原有值 40 与后面的 10 做减法，再将结果 30 赋值给 a

自增自减运算符

两个特殊运算符 ++ 与 –

++ 是让变量自增1，-- 是让变量自减1，举个例子

int a = 10;
a++;

结果为 11，++ 和 – 既可以写在变量之前，也可以写在变量之后，这两种写法的区别，我们到高级篇再讲，目前暂不用去了解

4. 练习 - 房贷计算器

【等额本息还款】法计算房贷

术语

  • 等额本息是指一种贷款的还款方式，是在还款期内，每月偿还同等数额的贷款（包括本金和利息）

  • 每月偿还的贷款可以通过下述公式计算

    p ∗ r ∗ ( 1 + r ) m / ( ( 1 + r ) m − 1 ) p * r * (1 + r)^m / ((1 + r)^m - 1) p∗r∗(1+r)m/((1+r)m−1)

    • p 为贷款本金 principal
    • r 为月利率 monthlyInterestRate
    • m 为还款月数 months

公式中这些都是什么意思呢

例如：贷款 200 万元 ，对应公式中的 p，200 万就是贷款本金，年利率 6%，月利率 mr 就是 6% / 12 = 0.5%，假设 10 年还清，这时还款月数就是 360 个月。套入公式计算即可得到每月还多少钱

要完成这个计算，有一点没学过的是求这里的 1+ mr 的 m 次方，计算它需要用一个求幂方法，这个方法是 jdk 核心类库中 Math 这个类提供的，Math的字面意思是数学，Math 类中提供了很多与数学计算相关的方法，如果你以后有这方面需求，就找它。

Math.pow()

pow 是 static 方法，语法为 类名.方法名(参数值)，它需要两个参数，参数1是底数，参数2是指数

jshell> Math.pow(2.0, 1)
$42 ==> 2.0

jshell> Math.pow(2.0, 2)
$43 ==> 4.0

jshell> Math.pow(2.0, 3)
$44 ==> 8.0

解答

打开 idea，编写 Calculator 类

public class Calculator 
    
    public static void main(String[] args) 
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入贷款本金 p");
        double p = scanner.nextDouble();
        
        System.out.println("请输入年利率 r%");
        double yr = scanner.nextDouble();
        double mr = yr / 100.0 / 12.0;
        
        System.out.println("请输入贷款月数 m");
        int m = scanner.nextInt();
        
        System.out.println(p * mr * Math.pow((1 + mr), m) / (Math.pow((1 + mr), m) - 1));

数字格式化

对结果的数字进行格式化，让它以货币的格式来显示

需要借助核心类库中一个 NumberFormat 对象，字面意思是数字格式化，使用它的 getCurrencyInstance 方法来获取一个货币格式化对象，再使用它的 format 方法把 double 小数格式化为货币格式，格式化时也会保留两位小数

例子

System.out.println(NumberFormat.getCurrencyInstance(Locale.CHINA).format(1000000.00));   System.out.println(NumberFormat.getCurrencyInstance(Locale.US).format(1000000.00));
System.out.println(NumberFormat.getCurrencyInstance(Locale.GERMANY).format(1000000.00));
System.out.println(NumberFormat.getCurrencyInstance(Locale.KOREA).format(1000000.00));

输出

¥1,000,000.00
$1,000,000.00
1.000.000,00 €
₩1,000,000

如果 Locale 省略不写，默认为中国

房贷计算器可以改写为

double payment = p * mr * Math.pow((1 + mr), m) / (Math.pow((1 + mr), m) - 1);       System.out.println(NumberFormat.getCurrencyInstance().format(payment));

查阅 Javadoc

javadoc 就是 java documentation 的缩写，我们下载的 jdk 中已经自带了，无需额外再下载。那怎么查阅 javadoc 呢，如果大家用的是 idea，那么可以通过一些快捷键来查阅java文档

  • 比如想看看类的文档，这时先按 Ctrl + N 查找类，假设我想看 Math 类的文档，输入要查阅的类名 Math，回车，可以跳转到这个类

  • 接下来我想看看方法的文档怎么办呢，按一下 ctrl + f12，列出当前类的所有方法，绿色表示可以使用方法，橙色带锁的，表示是该类一种特殊的私有方法，不能直接使用。找感兴趣的方法时，如果你懂一些英文单词，那么会有一定优势，例如你想找一个平方根方法，它对应的英文是 sqrt，这时敲入这几个字母，就会定位到方法，同样可以用翻译查看该方法的功能

  • 可以查到它的作用：返回一个数的平方根，这是方法名，查看后面括号内可以得知，需要一个参数，代表要求平方根的那个数字，是一个double 小数，方法名称前还有个 double 表示它的结果类型也是一个 double 小数

  • Math 中的方法大部分都是 static 方法，也就是配合类名使用的方法，之前也说过，用法为 类名.方法名(参数)

在平时写代码时，如果忘记了某个方法的作用，可以光标定位到该方法，按 Ctrl + Q 进行查阅，效果是类似的

三. 条件语句

编程时有一种重要的语句叫做条件语句，之前我们学过的都属于顺序语句，也就是从上至下，依次要执行每一行代码。

但是有的情况下，我们并不希望所有代码都执行，而是希望满足条件的代码才执行

例如：要对用户输入数据的合法性进行检查：

  • 贷款本金必须大于0
  • 贷款月数范围在 1 ~ 360 之间
  • 年利率范围在 1% ~ 36% 之间

如果你输入的值连这些条件都不满足，有必要去计算每月还款金额吗？

这种情况下，就要用到条件语句了，它的语法格式为

if(条件) 
    // 条件为 true 执行这里
 else 
    // 条件为 false 执行这里

什么意思呢，if 本意是如果，如果条件成立，执行代码1，else 本意是否则，即条件不成立，执行代码2，其中 else 语句块不是必须的，可以省略

那么条件这部分怎么写呢？对于数字类型可以借助比较运算符的运算结果来充当条件，参考下面的表格，这种表格列出了所有比较运算符

比较运算符含义
a == b判断 a 与 b 是否相等
a > b判断 a 是否 > b
a >= b判断 a 是否 >= b
a < b判断 a 是否 < b
a <= b判断 a 是否 <= b
a != b判断 a 与 b 是否不相等

1. boolean 类型

判断的结果是布尔类型，可以充当条件，它的取值非真即假，真用 true 表示，假用 false 表示

2. 单条件

jshell> int a = 1000;
a ==> 1000

jshell> if(a > 0)
   ...>     System.out.println("ok");
   ...>  else 
   ...>     System.out.println("必须>0");
   ...> 
ok

jshell> a = -1000;
a ==> -1000

jshell> if(a 第二章 Spring MVC入门






2．1、Spring Web MVC是什么


Spring Web MVC是一种基于Java的实现了Web MVC设计模式的请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将web层进行职责解耦，基于请求驱动指的就是使用请求-响应模型，框架的目的就是帮助我们简化开发，Spring Web MVC也是要简化我们日常Web开发的。


 


另外还有一种基于组件的、事件驱动的Web框架在此就不介绍了，如Tapestry、JSF等。


 


Spring Web MVC也是服务到工作者模式的实现，但进行可优化。前端控制器是DispatcherServlet；应用控制器其实拆为处理器映射器(Handler Mapping)进行处理器管理和视图解析器(View Resolver)进行视图管理；页面控制器/动作/处理器为Controller接口（仅包含ModelAndView handleRequest(request, response) 方法）的实现（也可以是任何的POJO类）；支持本地化（Locale）解析、主题（Theme）解析及文件上传等；提供了非常灵活的数据验证、格式化和数据绑定机制；提供了强大的约定大于配置（惯例优先原则）的契约式编程支持。


2．2、Spring Web MVC能帮我们做什么


√让我们能非常简单的设计出干净的Web层和薄薄的Web层；


√进行更简洁的Web层的开发；


√天生与Spring框架集成（如IoC容器、AOP等）；


√提供强大的约定大于配置的契约式编程支持；


√能简单的进行Web层的单元测试；


√支持灵活的URL到页面控制器的映射；


√非常容易与其他视图技术集成，如Velocity、FreeMarker等等，因为模型数据不放在特定的API里，而是放在一个Model里（Map数据结构实现，因此很容易被其他框架使用）；


√非常灵活的数据验证、格式化和数据绑定机制，能使用任何对象进行数据绑定，不必实现特定框架的API；


√提供一套强大的JSP标签库，简化JSP开发；


√支持灵活的本地化、主题等解析；


√更加简单的异常处理；


√对静态资源的支持；


√支持Restful风格。


2．3、Spring Web MVC架构


Spring Web MVC框架也是一个基于请求驱动的Web框架，并且也使用了前端控制器模式来进行设计，再根据请求映射规则分发给相应的页面控制器（动作/处理器）进行处理。首先让我们整体看一下Spring Web MVC处理请求的流程：


 


2.3.1、Spring Web MVC处理请求的流程


如图2-1


 技术分享


图2-1


具体执行步骤如下：


1、  首先用户发送请求————>前端控制器，前端控制器根据请求信息（如URL）来决定选择哪一个页面控制器进行处理并把请求委托给它，即以前的控制器的控制逻辑部分；图2-1中的1、2步骤；


2、  页面控制器接收到请求后，进行功能处理，首先需要收集和绑定请求参数到一个对象，这个对象在Spring Web MVC中叫命令对象，并进行验证，然后将命令对象委托给业务对象进行处理；处理完毕后返回一个ModelAndView（模型数据和逻辑视图名）；图2-1中的3、4、5步骤；


3、  前端控制器收回控制权，然后根据返回的逻辑视图名，选择相应的视图进行渲染，并把模型数据传入以便视图渲染；图2-1中的步骤6、7；


4、  前端控制器再次收回控制权，将响应返回给用户，图2-1中的步骤8；至此整个结束。


 


问题：


1、  请求如何给前端控制器？


2、  前端控制器如何根据请求信息选择页面控制器进行功能处理？


3、  如何支持多种页面控制器呢？


4、  如何页面控制器如何使用业务对象？


5、  页面控制器如何返回模型数据？


6、  前端控制器如何根据页面控制器返回的逻辑视图名选择具体的视图进行渲染？


7、  不同的视图技术如何使用相应的模型数据？


 


首先我们知道有如上问题，那这些问题如何解决呢？请让我们先继续，在后边依次回答。


 


2.3.2、Spring Web MVC架构


1、Spring Web MVC核心架构图，如图2-2


 技术分享


图2-2


 


 


架构图对应的DispatcherServlet核心代码如下：


 


java代码：





Java代码  技术分享




    

  1. //前端控制器分派方法  
  2. protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {  
  3.         HttpServletRequest processedRequest = request;  
  4.         HandlerExecutionChain mappedHandler = null;  
  5.         int interceptorIndex = -1;  
  6.   
  7.         try {  
  8.             ModelAndView mv;  
  9.             boolean errorView = false;  
  10.   
  11.             try {  
  12.                    //检查是否是请求是否是multipart（如文件上传），如果是将通过MultipartResolver解析  
  13.                 processedRequest = checkMultipart(request);  
  14.                    //步骤2、请求到处理器（页面控制器）的映射，通过HandlerMapping进行映射  
  15.                 mappedHandler = getHandler(processedRequest, false);  
  16.                 if (mappedHandler == null || mappedHandler.getHandler() == null) {  
  17.                     noHandlerFound(processedRequest, response);  
  18.                     return;  
  19.                 }  
  20.                    //步骤3、处理器适配，即将我们的处理器包装成相应的适配器（从而支持多种类型的处理器）  
  21.                 HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());  
  22.   
  23.                   // 304 Not Modified缓存支持  
  24.                 //此处省略具体代码  
  25.   
  26.                 // 执行处理器相关的拦截器的预处理（HandlerInterceptor.preHandle）  
  27.                 //此处省略具体代码  
  28.   
  29.                 // 步骤4、由适配器执行处理器（调用处理器相应功能处理方法）  
  30.                 mv = ha.handle(processedRequest, response, mappedHandler.getHandler());  
  31.   
  32.                 // Do we need view name translation?  
  33.                 if (mv != null && !mv.hasView()) {  
  34.                     mv.setViewName(getDefaultViewName(request));  
  35.                 }  
  36.   
  37.                 // 执行处理器相关的拦截器的后处理（HandlerInterceptor.postHandle）  
  38.                 //此处省略具体代码  
  39.             }  
  40.             catch (ModelAndViewDefiningException ex) {  
  41.                 logger.debug("ModelAndViewDefiningException encountered", ex);  
  42.                 mv = ex.getModelAndView();  
  43.             }  
  44.             catch (Exception ex) {  
  45.                 Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);  
  46.                 mv = processHandlerException(processedRequest, response, handler, ex);  
  47.                 errorView = (mv != null);  
  48.             }  
  49.   
  50.             //步骤5 步骤6、解析视图并进行视图的渲染  
  51. //步骤5 由ViewResolver解析View（viewResolver.resolveViewName(viewName, locale)）  
  52. //步骤6 视图在渲染时会把Model传入（view.render(mv.getModelInternal(), request, response);）  
  53.             if (mv != null && !mv.wasCleared()) {  
  54.                 render(mv, processedRequest, response);  
  55.                 if (errorView) {  
  56.                     WebUtils.clearErrorRequestAttributes(request);  
  57.                 }  
  58.             }  
  59.             else {  
  60.                 if (logger.isDebugEnabled()) {  
  61.                     logger.debug("Null ModelAndView returned to DispatcherServlet with name ‘" + getServletName() +  
  62.                             "‘: assuming HandlerAdapter completed request handling");  
  63.                 }  
  64.             }  
  65.   
  66.             // 执行处理器相关的拦截器的完成后处理（HandlerInterceptor.afterCompletion）  
  67.             //此处省略具体代码  
  68.   
  69.   
  70.         catch (Exception ex) {  
  71.             // Trigger after-completion for thrown exception.  
  72.             triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);  
  73.             throw ex;  
  74.         }  
  75.         catch (Error err) {  
  76.             ServletException ex = new NestedServletException("Handler processing failed", err);  
  77.             // Trigger after-completion for thrown exception.  
  78.             triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);  
  79.             throw ex;  
  80.         }  
  81.   
  82.         finally {  
  83.             // Clean up any resources used by a multipart request.  
  84.             if (processedRequest != request) {  
  85.                 cleanupMultipart(processedRequest);  
  86.             }  
  87.         }  
  88.     }  






 


核心架构的具体流程步骤如下：


1、  首先用户发送请求——>DispatcherServlet，前端控制器收到请求后自己不进行处理，而是委托给其他的解析器进行处理，作为统一访问点，进行全局的流程控制；


2、  DispatcherServlet——>HandlerMapping， HandlerMapping将会把请求映射为HandlerExecutionChain对象（包含一个Handler处理器（页面控制器）对象、多个HandlerInterceptor拦截器）对象，通过这种策略模式，很容易添加新的映射策略；


3、  DispatcherServlet——>HandlerAdapter，HandlerAdapter将会把处理器包装为适配器，从而支持多种类型的处理器，即适配器设计模式的应用，从而很容易支持很多类型的处理器；


4、  HandlerAdapter——>处理器功能处理方法的调用，HandlerAdapter将会根据适配的结果调用真正的处理器的功能处理方法，完成功能处理；并返回一个ModelAndView对象（包含模型数据、逻辑视图名）；


5、  ModelAndView的逻辑视图名——> ViewResolver， ViewResolver将把逻辑视图名解析为具体的View，通过这种策略模式，很容易更换其他视图技术；


6、  View——>渲染，View会根据传进来的Model模型数据进行渲染，此处的Model实际是一个Map数据结构，因此很容易支持其他视图技术；


7、返回控制权给DispatcherServlet，由DispatcherServlet返回响应给用户，到此一个流程结束。


 


此处我们只是讲了核心流程，没有考虑拦截器、本地解析、文件上传解析等，后边再细述。


 


到此，再来看我们前边提出的问题：


 


 


1、  请求如何给前端控制器？这个应该在web.xml中进行部署描述，在HelloWorld中详细讲解。


2、  前端控制器如何根据请求信息选择页面控制器进行功能处理？ 我们需要配置HandlerMapping进行映射


3、  如何支持多种页面控制器呢？配置HandlerAdapter从而支持多种类型的页面控制器


4、  如何页面控制器如何使用业务对象？可以预料到，肯定利用Spring IoC容器的依赖注入功能


5、  页面控制器如何返回模型数据？使用ModelAndView返回


6、  前端控制器如何根据页面控制器返回的逻辑视图名选择具体的视图进行渲染？ 使用ViewResolver进行解析


7、  不同的视图技术如何使用相应的模型数据？ 因为Model是一个Map数据结构，很容易支持其他视图技术


 


在此我们可以看出具体的核心开发步骤：


1、  DispatcherServlet在web.xml中的部署描述，从而拦截请求到Spring Web MVC


2、  HandlerMapping的配置，从而将请求映射到处理器


3、  HandlerAdapter的配置，从而支持多种类型的处理器


4、  ViewResolver的配置，从而将逻辑视图名解析为具体视图技术


5、处理器（页面控制器）的配置，从而进行功能处理


 


上边的开发步骤我们会在Hello World中详细验证。


 


2．4、Spring Web MVC优势


1、清晰的角色划分：前端控制器（DispatcherServlet）、请求到处理器映射（HandlerMapping）、处理器适配器（HandlerAdapter）、视图解析器（ViewResolver）、处理器或页面控制器（Controller）、验证器（   Validator）、命令对象（Command  请求参数绑定到的对象就叫命令对象）、表单对象（Form Object 提供给表单展示和提交到的对象就叫表单对象）。


2、分工明确，而且扩展点相当灵活，可以很容易扩展，虽然几乎不需要；


3、由于命令对象就是一个POJO，无需继承框架特定API，可以使用命令对象直接作为业务对象；


4、和Spring 其他框架无缝集成，是其它Web框架所不具备的；


5、可适配，通过HandlerAdapter可以支持任意的类作为处理器；


6、可定制性，HandlerMapping、ViewResolver等能够非常简单的定制；


7、功能强大的数据验证、格式化、绑定机制；


8、利用Spring提供的Mock对象能够非常简单的进行Web层单元测试；


9、本地化、主题的解析的支持，使我们更容易进行国际化和主题的切换。


10、强大的JSP标签库，使JSP编写更容易。


………………还有比如RESTful风格的支持、简单的文件上传、约定大于配置的契约式编程支持、基于注解的零配置支持等等。


 


到此我们已经简单的了解了Spring Web MVC，接下来让我们来个实例来具体使用下这个框架。


2．5、Hello World入门


2.5.1、准备开发环境和运行环境：


☆开发工具：eclipse


☆运行环境：tomcat6.0.20


☆工程：动态web工程（springmvc-chapter2）


☆spring框架下载：


spring-framework-3.1.1.RELEASE-with-docs.zip


☆依赖jar包：


1、  Spring框架jar包：


为了简单，将spring-framework-3.1.1.RELEASE-with-docs.zip/dist/下的所有jar包拷贝到项目的WEB-INF/lib目录下；


2、  Spring框架依赖的jar包：


需要添加Apache commons logging日志，此处使用的是commons.logging-1.1.1.jar；


需要添加jstl标签库支持，此处使用的是jstl-1.1.2.jar和standard-1.1.2.jar；


2.5.2、前端控制器的配置


在我们的web.xml中添加如下配置：


 


java代码：





Java代码  技术分享




    

  1. <servlet>  
  2.     <servlet-name>chapter2</servlet-name>  
  3.     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
  4.     <load-on-startup>1</load-on-startup>  
  5. </servlet>  
  6. <servlet-mapping>  
  7.     <servlet-name>chapter2</servlet-name>  
  8.     <url-pattern>/</url-pattern>  
  9. </servlet-mapping>  






load-on-startup：表示启动容器时初始化该Servlet；


url-pattern：表示哪些请求交给Spring Web MVC处理， “/” 是用来定义默认servlet映射的。也可以如“*.html”表示拦截所有以html为扩展名的请求。


 


自此请求已交给Spring Web MVC框架处理，因此我们需要配置Spring的配置文件，默认DispatcherServlet会加载WEB-INF/[DispatcherServlet的Servlet名字]-servlet.xml配置文件。本示例为WEB-INF/ chapter2-servlet.xml。


 


2.5.3、在Spring配置文件中配置HandlerMapping、HandlerAdapter


具体配置在WEB-INF/ chapter2-servlet.xml文件中：


 


java代码：





Java代码  技术分享




    

  1. <!-- HandlerMapping -->  
  2. <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>  
  3.    
  4. <!-- HandlerAdapter -->  
  5. <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>  






 


BeanNameUrlHandlerMapping：表示将请求的URL和Bean名字映射，如URL为 “上下文/hello”，则Spring配置文件必须有一个名字为“/hello”的Bean，上下文默认忽略。


SimpleControllerHandlerAdapter：表示所有实现了org.springframework.web.servlet.mvc.Controller接口的Bean可以作为Spring Web MVC中的处理器。如果需要其他类型的处理器可以通过实现HadlerAdapter来解决。


2.5.4、在Spring配置文件中配置ViewResolver


具体配置在WEB-INF/ chapter2-servlet.xml文件中：


 


java代码：





Java代码  技术分享




    

  1. <!-- ViewResolver -->  
  2. <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
  3.     <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>  
  4.     <property name="prefix" value="/WEB-INF/jsp/"/>  
  5.     <property name="suffix" value=".jsp"/>  
  6. </bean>  






 


InternalResourceViewResolver：用于支持Servlet、JSP视图解析；


    viewClass：JstlView表示JSP模板页面需要使用JSTL标签库，classpath中必须包含jstl的相关jar包；


    prefix和suffix：查找视图页面的前缀和后缀（前缀[逻辑视图名]后缀），比如传进来的逻辑视图名为hello，则该该jsp视图页面应该存放在“WEB-INF/jsp/hello.jsp”；


 


2.5.5、开发处理器/页面控制器


 


java代码：





Java代码  技术分享




    

  1. package cn.javass.chapter2.web.controller;  
  2. import javax.servlet.http.HttpServletRequest;  
  3. import javax.servlet.http.HttpServletResponse;  
  4. import org.springframework.web.servlet.ModelAndView;  
  5. import org.springframework.web.servlet.mvc.Controller;  
  6. public class HelloWorldController implements Controller {  
  7.     @Override  
  8.     public ModelAndView handleRequest(HttpServletRequest req, HttpServletResponse resp) throws Exception {  
  9.        //1、收集参数、验证参数  
  10.        //2、绑定参数到命令对象  
  11.        //3、将命令对象传入业务对象进行业务处理  
  12.        //4、选择下一个页面  
  13.        ModelAndView mv = new ModelAndView();  
  14.        //添加模型数据 可以是任意的POJO对象  
  15.        mv.addObject("message", "Hello World!");  
  16.        //设置逻辑视图名，视图解析器会根据该名字解析到具体的视图页面  
  17.        mv.setViewName("hello");  
  18.        return mv;  
  19.     }  
  20. }  






 


org.springframework.web.servlet.mvc.Controller：页面控制器/处理器必须实现Controller接口，注意别选错了；后边我们会学习其他的处理器实现方式；


public ModelAndView handleRequest(HttpServletRequest req, HttpServletResponse resp) ：功能处理方法，实现相应的功能处理，比如收集参数、验证参数、绑定参数到命令对象、将命令对象传入业务对象进行业务处理、最后返回ModelAndView对象；


ModelAndView：包含了视图要实现的模型数据和逻辑视图名；“mv.addObject("message", "Hello World!");


”表示添加模型数据，此处可以是任意POJO对象；“mv.setViewName("hello");”表示设置逻辑视图名为“hello”，视图解析器会将其解析为具体的视图，如前边的视图解析器InternalResourceVi。wResolver会将其解析为“WEB-INF/jsp/hello.jsp”。


 


 


我们需要将其添加到Spring配置文件(WEB-INF/chapter2-servlet.xml)，让其接受Spring IoC容器管理:


 


java代码：





Java代码  技术分享




    

  1. <!-- 处理器 -->  
  2. <bean name="/hello" class="cn.javass.chapter2.web.controller.HelloWorldController"/>  






 


name="/hello"：前边配置的BeanNameUrlHandlerMapping，表示如过请求的URL为 “上下文/hello”，则将会交给该Bean进行处理。 


2.5.6、开发视图页面


创建 /WEB-INF/jsp/hello.jsp视图页面：


 


java代码：





Java代码  技术分享




    

  1. <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>  
  2. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">  
  3. <html>  
  4. <head>  
  5. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">  
  6. <title>Hello World</title>  
  7. </head>  
  8. <body>  
  9. ${message}  
  10. </body>  
  11. </html>  






 


${message}：表示显示由HelloWorldController处理器传过来的模型数据。


2.5.6、启动服务器运行测试


通过请求：http://localhost:9080/springmvc-chapter2/hello，如果页面输出“Hello World! ”就表明我们成功了！


 


 


2.5.7、运行流程分析


如图2-3


 技术分享


图2-3


运行步骤：


1、  首先用户发送请求http://localhost:9080/springmvc-chapter2/hello——>web容器，web容器根据“/hello”路径映射到DispatcherServlet（url-pattern为/）进行处理；


2、  DispatcherServlet——>BeanNameUrlHandlerMapping进行请求到处理的映射，BeanNameUrlHandlerMapping将“/hello”路径直接映射到名字为“/hello”的Bean进行处理，即HelloWorldController，BeanNameUrlHandlerMapping将其包装为HandlerExecutionChain（只包括HelloWorldController处理器，没有拦截器）；


3、  DispatcherServlet——> SimpleControllerHandlerAdapter，SimpleControllerHandlerAdapter将HandlerExecutionChain中的处理器（HelloWorldController）适配为SimpleControllerHandlerAdapter；


4、  SimpleControllerHandlerAdapter——> HelloWorldController处理器功能处理方法的调用，SimpleControllerHandlerAdapter将会调用处理器的handleRequest方法进行功能处理，该处理方法返回一个ModelAndView给DispatcherServlet；


5、  hello（ModelAndView的逻辑视图名）——>InternalResourceViewResolver， InternalResourceViewResolver使用JstlView，具体视图页面在/WEB-INF/jsp/hello.jsp；


6、  JstlView（/WEB-INF/jsp/hello.jsp）——>渲染，将在处理器传入的模型数据(message=HelloWorld！)在视图中展示出来；


7、  返回控制权给DispatcherServlet，由DispatcherServlet返回响应给用户，到此一个流程结束。


 


到此HelloWorld就完成了，步骤是不是有点多？而且回忆下我们主要进行了如下配置：


 


1、  前端控制器DispatcherServlet；


2、  HandlerMapping


3、  HandlerAdapter


4、  ViewResolver


5、  处理器/页面控制器


6、  视图


 


因此，接下来几章让我们详细看看这些配置，先从DispatcherServlet开始吧。


 


2．6、POST中文乱码解决方案


spring Web MVC框架提供了org.springframework.web.filter.CharacterEncodingFilter用于解决POST方式造成的中文乱码问题，具体配置如下：


 


java代码：





Java代码  技术分享




    

  1. <filter>  
  2.     <filter-name>CharacterEncodingFilter</filter-name>  
  3.     <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>  
  4.     <init-param>  
  5.         <param-name>encoding</param-name>  
  6.         <param-value>utf-8</param-value>  
  7.     </init-param>  
  8. </filter>  
  9. <filter-mapping>  
  10.     <filter-name>CharacterEncodingFilter</filter-name>  
  11.     <url-pattern>/*</url-pattern>  
  12. </filter-mapping>  






 


以后我们项目及所有页面的编码均为UTF-8。


 


 


2.7、Spring3.1新特性


一、Spring2.5之前，我们都是通过实现Controller接口或其实现来定义我们的处理器类。


 


二、Spring2.5引入注解式处理器支持，通过@Controller 和 @RequestMapping注解定义我们的处理器类。并且提供了一组强大的注解：


 


需要通过处理器映射DefaultAnnotationHandlerMapping和处理器适配器AnnotationMethodHandlerAdapter来开启支持@Controller 和 @RequestMapping注解的处理器。


 


@Controller：用于标识是处理器类；


@RequestMapping：请求到处理器功能方法的映射规则；


@RequestParam：请求参数到处理器功能处理方法的方法参数上的绑定；


@ModelAttribute：请求参数到命令对象的绑定；


@SessionAttributes：用于声明session级别存储的属性，放置在处理器类上，通常列出模型属性（如@ModelAttribute）对应的名称，则这些属性会透明的保存到session中；


@InitBinder：自定义数据绑定注册支持，用于将请求参数转换到命令对象属性的对应类型；


 


三、Spring3.0引入RESTful架构风格支持(通过@PathVariable注解和一些其他特性支持),且又引入了更多的注解支持：


@CookieValue：cookie数据到处理器功能处理方法的方法参数上的绑定；


@RequestHeader：请求头（header）数据到处理器功能处理方法的方法参数上的绑定；


@RequestBody：请求的body体的绑定（通过HttpMessageConverter进行类型转换）；


@ResponseBody：处理器功能处理方法的返回值作为响应体（通过HttpMessageConverter进行类型转换）；


@ResponseStatus：定义处理器功能处理方法/异常处理器返回的状态码和原因；


@ExceptionHandler：注解式声明异常处理器；


@PathVariable：请求URI中的模板变量部分到处理器功能处理方法的方法参数上的绑定，从而支持RESTful架构风格的URI；


 


四、还有比如：


JSR-303验证框架的无缝支持（通过@Valid注解定义验证元数据）；


使用Spring 3开始的ConversionService进行类型转换（PropertyEditor依然有效）
以上是关于java入门-W2的主要内容，如果未能解决你的问题，请参考以下文章
 

 01-Java语言概述与开发环境  最适合入门的Java教程


 Java入门 - 语言基础 - 02.开发环境配置


 Java入门 - 语言基础 - 02.开发环境配置


 01--Java语言概述与开发环境  最适合入门的Java教程


 简单的入门Android开发和Java语言基础[图]


 经验分享新手学Java编程语言怎么入门？