小菜鸟之SSM框架

  1 # SSM框架
  2
  3 # **什么是框架**
  4
  5 就是模板，将一些基础性的程序和代码由框架模板提供，然后程序员补充和业务需求相关的代码。
  6
  7 # **ssm框架组成**
  8
  9 s: springMvc 子框架  代替servlet类，control层
 10
 11 s: spring     框架系列
 12
 13 ​			基本作用：创建对象（控制反转和依赖注入）
 14
 15 m: mybatis 框架  代替dao包，和数据库进行交互（jdbc技术），表     		示model层（service包和dao包）
 16
 17 **补充**
 18
 19 ​	view层：视图层，还是使用jsp实现
 20
 21 # **项目演示**
 22
 23 ## 目标：用户管理项目
 24
 25 ## 操作步骤：
 26
 27 ### 1、创建maven项目，并配置tomcat服务器
 28
 29 **配置tomcat时无artifact选项解决方案**
 30
 31 <img src="img/1573611676801.png" alt="1573611676801" style="zoom:33%;" />
 32
 33
 34
 35 打开
 36
 37 <img src="img/1573611734587.png" alt="1573611734587" style="zoom:33%;" />
 38
 39 选择
 40
 41 <img src="img/1573611802769.png" alt="1573611802769" style="zoom:33%;" />
 42
 43
 44
 45 ### 2、创建java和resources目录，并mark一下，新建文件夹变色
 46
 47 ![1573519990356](img/ssm.md)
 48
 49 java文件夹：存放程序员编写的java代码
 50
 51 resources文件夹：存放配置文件（和ssm框架相关）
 52
 53 ### 3、myBatis框架（替代jdbc技术）
 54
 55 #### 3.1 导入和mybatis相关的依赖（包）
 56
 57 mybatis
 58
 59  mybatis-spring
 60
 61 mysql-connector-java
 62
 63 ```xml
 64 <!--mybatis-->
 65     <dependency>
 66       <groupId>org.mybatis</groupId>
 67       <artifactId>mybatis</artifactId>
 68       <version>3.5.2</version>
 69     </dependency>
 70     <!--mybatis-spring 二者的整合-->
 71     <dependency>
 72       <groupId>org.mybatis</groupId>
 73       <artifactId>mybatis-spring</artifactId>
 74       <version>2.0.2</version>
 75     </dependency>
 76     <!--mysql-connector-java  用于java程序连接mysql数据库-->
 77     <dependency>
 78       <groupId>mysql</groupId>
 79       <artifactId>mysql-connector-java</artifactId>
 80       <version>8.0.17</version>
 81     </dependency>
 82 ```
 83
 84 #### 3.2 在resources文件夹中创建文件mybatis-config.xml
 85
 86 ```xml
 87 <?xml version="1.0" encoding="UTF-8" ?>
 88 <!DOCTYPE configuration
 89         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
 90         "http://mybatis.org/dtd/mybatis-3-config.dtd">
 91 <configuration>
 92 <!--该文件中可以对mybatis框架进行一些配置设置-->
 93
 94 </configuration>
 95 ```
 96
 97 ### 4.spring框架
 98
 99 #### 4.1添加和spring相关的常用的依赖
100
101 spring-beans
102
103 spring-context/spring-context-support
104
105 spring-core
106
107 spring-expression
108
109 spring-jdbc
110
111 spring-tx
112
113 spring-web
114
115 commons-dbcp
116
117 ```xml
118 <dependency>
119       <groupId>org.springframework</groupId>
120       <artifactId>spring-beans</artifactId>
121       <version>5.1.8.RELEASE</version>
122     </dependency>
123     <dependency>
124       <groupId>org.springframework</groupId>
125       <artifactId>spring-context</artifactId>
126       <version>5.1.8.RELEASE</version>
127     </dependency>
128     <dependency>
129       <groupId>org.springframework</groupId>
130       <artifactId>spring-context-support</artifactId>
131       <version>5.0.10.RELEASE</version>
132     </dependency>
133     <dependency>
134       <groupId>org.springframework</groupId>
135       <artifactId>spring-core</artifactId>
136       <version>5.1.8.RELEASE</version>
137     </dependency>
138     <dependency>
139       <groupId>org.springframework</groupId>
140       <artifactId>spring-expression</artifactId>
141       <version>5.1.8.RELEASE</version>
142     </dependency>
143     <dependency>
144       <groupId>org.springframework</groupId>
145       <artifactId>spring-jdbc</artifactId>
146       <version>5.0.10.RELEASE</version>
147     </dependency>
148     <dependency>
149       <groupId>org.springframework</groupId>
150       <artifactId>spring-tx</artifactId>
151       <version>5.1.8.RELEASE</version>
152     </dependency>
153     <dependency>
154       <groupId>org.springframework</groupId>
155       <artifactId>spring-web</artifactId>
156       <version>5.1.8.RELEASE</version>
157     </dependency>
158
159     <!--commons-dbcp 用于创建dataSource数据源-->
160     <dependency>
161       <groupId>commons-dbcp</groupId>
162       <artifactId>commons-dbcp</artifactId>
163       <version>1.4</version>
164     </dependency>
165 ```
166
167
168
169 #### 4.2在resources文件夹创建applicationContext.xml文件，用于对spring框架配置的设置
170
171 ```xml
172 <?xml version="1.0" encoding="UTF-8"?>
173 <beans xmlns="http://www.springframework.org/schema/beans"
174        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
175        xmlns:context="http://www.springframework.org/schema/context"
176        xsi:schemaLocation="http://www.springframework.org/schema/beans
177        http://www.springframework.org/schema/beans/spring-beans.xsd
178        http://www.springframework.org/schema/context
179        https://www.springframework.org/schema/context/spring-context.xsd">
180 <!--用于spring框架的配置设置-->
181
182 </beans>
183 ```
184
185 ### 5.springmvc框架
186
187 #### 5.1添加依赖（jar包）
188
189 spring-mvc
190
191 ```xml
192     <!--springmvc的依赖-->
193     <dependency>
194       <groupId>org.springframework</groupId>
195       <artifactId>spring-webmvc</artifactId>
196       <version>5.1.5.RELEASE</version>
197     </dependency>
198 ```
199
200
201
202 #### 5.2在resources目录下创建springmvc-servlet.xml文件，对springmvc进行的配置设置
203
204 ```xml
205 <?xml version="1.0" encoding="UTF-8"?>
206 <beans xmlns="http://www.springframework.org/schema/beans"
207        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
208        xmlns:mvc="http://www.springframework.org/schema/mvc"
209      xmlns:context="http://www.springframework.org/schema/context"       xsi:schemaLocation="http://www.springframework.org/schema/beans
210        http://www.springframework.org/schema/beans/spring-beans.xsd
211        http://www.springframework.org/schema/context
212        https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
213     <!--该文件用于对springmc框架的配置设置-->
214
215
216 </beans>
217 ```
218
219 #### **注意处理**
220
221 ![1573526006338](img/1573526006338.png)
222
223
224
225 ### 6.在java目录下创建一些基本的包
226
227 dao  :用于连接数据库
228
229 service：用于进行业务逻辑的处理
230
231 controller：用于对请求的派发和处理
232
233 pojo：将数据库的表名定义为类名，字段定义为属性,此类放在此包中
234
235 interceptor：拦截器包，使用的场景：处理非法登陆。
236
237 util：工具包，存放一些工具类，比如jdbcUtil，分页插件类等等。
238
239 test：测试包，用于测试，junit等进行测试。
240
241 <img src="img/1573526271379.png" alt="1573526271379" style="zoom:33%;" />
242
243 ### 7.pojo中类的创建和编写
244
245 根据数据库中的表创建对应类，好处是通过操作pojo类，来代替操作数据库中的表（对象关系映射orm技术）
246
247 ```java
248 //表名对应类名
249 public class User {
250
251     //表字段对应类属性
252     private int id;
253     private String username;
254     private String password;
255
256     public int getId() {
257         return id;
258     }
259
260     public void setId(int id) {
261         this.id = id;
262     }
263
264     public String getUsername() {
265         return username;
266     }
267
268     public void setUsername(String username) {
269         this.username = username;
270     }
271
272     public String getPassword() {
273         return password;
274     }
275
276     public void setPassword(String password) {
277         this.password = password;
278     }
279 }
280
281 ```
282
283 ### 8、在resources目录下，创建database.properties文件，该文件中编写：driver，url,username,password等连接数据库的参数
284
285 ```xml
286 driver=com.mysql.jdbc.Driver
287 url=jdbc:mysql://127.0.0.1:3306/school?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
288 user=root
289 password=root
290 ```
291
292 ### 9、进行java应用项目连接数据库
293
294 **在applicationContext.xml文件下**
295
296 ```xml
297 <!--1 引入database.properties文件-->
298 <context:property-placeholder location="classpath:database.properties"/>
299
300 <!--2 创建数据源-->
301     <!--基本数据源（配置数据源）-->
302     <!-- 配置数据源，核心类：基本数据源BasicDataSource类 -->
303     <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close" scope="singleton">
304         <property name="driverClassName" value="${driver}"/>
305         <property name="url" value="${url}"/>
306         <property name="username" value="${user}"/>
307         <property name="password" value="${password}"/>
308     </bean>
309
310     <!--3 对数据源进行事务管理-->
311     <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
312         <property name="dataSource" ref="dataSource"/>
313     </bean>
314
315     <!--4 配置mybatis核心类SqlSessionFactoryBean，引入数据源，引入mybatis-config.xml-->
316     <bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
317         <property name="dataSource" ref="dataSource"/>
318         <property name="configLocation" value="classpath:mybatis-config.xml"/>
319     </bean>
320 ```
321
322 ### 10、在dao包中创建接口和mapper文件，在spring配置文件中配置
323
324 在mapper文件中编写sql语句
325
326 <img src="img/1573530423150.png" alt="1573530423150" style="zoom:25%;" />
327
328 #### **a 创建接口UserMapper**
329
330 ```java
331 public interface UserMapper {
332     //登陆功能
333     public User login(@Param("xiaomao")String username,@Param("xiaogou")String password);
334 }
335 ```
336
337
338
339 #### **b 创建UserMapper文件**
340
341 ```xml
342 <?xml version="1.0" encoding="UTF-8" ?>
343 <!DOCTYPE mapper
344         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
345         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
346 <mapper namespace="com.baidu.dao.UserMapper">
347     <!--namespace 赋值：对应的接口全路径-->
348         <!--select * from user where username=? and password=?-->
349     <!--id 填写 对应的接口方法名， resultType 填写接口方法的返回类型-->
350     <!--登陆方法-->
351     <select id="login" resultType="com.baidu.pojo.User">
352         select * from user where username=#{xiaomao} and password=#{xiaogou}
353     </select>
354 </mapper>
355 ```
356
357 #### c 在applicationContext中配置对mapper文件扫描
358
359 ```xml
360     <!--映射扫描配置器（引入sql映射文件）-->
361     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
362         <property name="basePackage" value="com.baidu.dao"/>
363     </bean>
364 ```
365
366 #### d 在pom.xml中<build>内添加
367
368 **将src/main/java目录下的所有*.xml文件编译到class内，不然报错：找不到mapper文件**
369
370 ```xml
371 <build>
372       <!--将java目录下的所有*.xml文件编译到class内，不然报错：找不到mapper文件-->
373     <resources>
374       <resource>
375         <directory>src/main/java</directory>
376         <includes>
377           <include>**/*.xml</include>
378         </includes>
379         <filtering>false</filtering>
380       </resource>
381     </resources>
382 </build>
383 ```
384
385
386
387 ### 11、在service包中创建接口和实现类，编写业务逻辑代码
388
389 #### 接口
390
391 ```java
392 public interface UserService {
393     //登陆功能
394     public boolean login(String username,String password);
395 }
396 ```
397
398 #### 实现类
399
400 ```java
401 public class UserServiceImpl implements  UserService {
402
403     @Resource//此时报错，缺少依赖：javax.annotation-api
404     private UserMapper userMapper=null;
405
406     //登陆方法
407     public boolean login(String username, String password) {
408         User user = userMapper.login(username, password);
409         boolean flag=false;
410         if(user!=null){//用户存在
411             flag=true;
412         }
413         return flag;
414     }
415 }
416 ```
417
418 #### **补充支持@Resource注解的依赖**
419
420 ```xml
421     <!--@Resource-->
422     <dependency>
423       <groupId>javax.annotation</groupId>
424       <artifactId>javax.annotation-api</artifactId>
425       <version>1.3.1</version>
426     </dependency>
427 ```
428
429
430
431 ### 12、在applicationContext.xml文件中对组件进行定义和扫描
432
433 #### **组件扫描**
434
435 ##### a、定义组件
436
437 编写userController类，将@Controller 放在controller包的类上
438
439 ```java
440 @Controller
441 public class UserController {
442    //编写对请求的派发和处理
443
444 }
445 ```
446
447 @Service  放在service包的实现类上
448
449 ```java
450 public interface UserService {
451     //登陆功能
452     public boolean login(String username,String password);
453 }
454 ```
455
456 ```
457 @Service
458 public class UserServiceImpl implements  UserService {
459
460     @Autowired//@Resource同一功能
461     private UserMapper userMapper=null;
462
463     //登陆方法
464     public boolean login(String username, String password) {
465         User user = userMapper.login(username, password);
466         boolean flag=false;
467         if(user!=null){//用户存在
468             flag=true;
469         }
470         return flag;
471     }
472 }
473 ```
474
475
476
477 @Repository 放在dao包的实现类上（如果没有实现类，就省略）
478
479 ```java
480 public interface UserMapper {
481     //登陆功能
482     public User login(@Param("xiaomao") String username, @Param("xiaogou") String password);
483 }
484 ```
485
486 ##### b、在applicationContext.xml容器中配置，使组件生效
487
488 ```xml
489 <!--组件浏览-->
490     <context:component-scan base-package="com.baidu.service"/>
491     <context:component-scan base-package="com.baidu.dao"/>
492
493     <!--注解配置-->
494     <context:annotation-config/>
495 ```
496
497 ##### c、在springmvc-serlvet.xml容器中配置，使组件生效
498
499 ```java
500 <!-- 支持组件-->
501     <context:component-scan base-package="com.baidu.controller"/>
502 ```
503
504 ### 13、配置web.xml文件
505
506 #### a."<web-app>"中添加属性
507
508 ```xml
509 <web-app
510         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
511         xmlns="http://java.sun.com/xml/ns/javaee"
512         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
513         id="WebApp_ID" version="3.0">
514 ```
515
516 #### b、配置监听器
517
518 ```xml
519   <!-- 配置监听器  -->
520   <listener>
521     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
522   </listener>
523 ```
524
525 #### c、引入spring配置文件
526
527 ```xml
528   <!--引入spring的配置文件，制定文件的位置-->
529   <context-param>
530     <param-name>contextConfigLocation</param-name>
531     <param-value>classpath:applicationContext.xml</param-value>
532   </context-param>
533 ```
534
535 #### d、配置DispatcherServlet（类似于“总机调度”）
536
537 ```xml
538 <!--配置DispatcherServlet-->
539   <servlet>
540     <servlet-name>DispatcherServlet</servlet-name>
541     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
542     <init-param>
543       <param-name>contextConfigLocation</param-name>
544       <param-value>classpath:springmvc-servlet.xml</param-value>
545     </init-param>
546     <load-on-startup>1</load-on-startup>
547   </servlet>
548   <servlet-mapping>
549     <servlet-name>DispatcherServlet</servlet-name>
550     <!--所有的请求都要被拦截，然后进行转发-->
551     <url-pattern>/</url-pattern>
552   </servlet-mapping>
553 ```
554
555 ### 14、配置springmvc-servlet.xml
556
557 #### a、配置对组件@Controller的扫描（上述已经操作）
558
559 ```xml
560    <!-- 支持组件-->
561     <context:component-scan base-package="com.baidu.controller"/>
562 ```
563
564 #### b、支持注解
565
566 (@RequestMapping，@RequestParam等)
567
568 ```xml
569 <!--支持注解-->
570 <mvc:annotation-driven/>
571 ```
572
573 #### c、配置视图解析器
574
575 - /WEB-INF/下创建jsp文件夹
576
577 - 通过逻辑视图名（jsp文件的文件名）找到真实的视图名（jsp文件的全名）
578
579   ​	举例：  真实的视图名 index.jsp 《---逻辑视图名 jsp
580
581   ​	比如： /WEB-INF/jsp/index.jsp
582
583 ```xml
584 <!--配置视图解析器-->
585 <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
586 <property name="prefix" value="/WEB-INF/jsp/"/>
587 <property name="suffix" value=".jsp"/>
588 </bean>
589 ```
590
591 #### d、引入静态资源
592
593 - 在webapp下创建statics文件夹
594 - 在springmvc-servlet.xml配置文件中添加
595
596 ```xml
597 <!--引入静态资源--><mvc:resources mapping="/statics/**" location="/statics/"/>
598 ```
599
600 ### 15、在controller类中创建控制器方法
601
602 ```java
603 /**
604  * @author 四两数字先生（CSDN/公众号）
605  */
606 @Controller
607 @RequestMapping("/user")
608 public class UserController {
609
610     //private UserService userService=new UserServiceImpl();
611     @Resource  //自动装配
612     private UserService userService;
613
614     @RequestMapping("/index")
615     public String index(){
616         return "index";//index就是逻辑视图名
617     }
618     @RequestMapping("/login")
619     public String login(@RequestParam(value = "xiaogou",required = false) String username,
620                         @RequestParam(value = "xiaomao",required = false) String password){
621         boolean flag = this.userService.login(username, password);
622         if(flag){//用户存在
623             return "success";
624              }
625         return "failure";
626     }
627 }
628 ```
629
630 ### 16、编写jsp文件index.jsp
631
632 a.编写登陆表单
633
634 ```html
635 <form method="get" action="<%=request.getContextPath() %>/user/login">
636     用户名：<input type="text" name="xiaogou" value="">
637     密码：<input type="password" name="xiaomao" value="">
638     <input type="submit" name="submit" value="登陆">
639 </form>
640 ```
641
642 b.添加 sevlet-api依赖
643
644 ```xml
645     <!--servlet-api-->
646     <dependency>
647       <groupId>javax.servlet</groupId>
648       <artifactId>javax.servlet-api</artifactId>
649       <version>4.0.1</version>
650     </dependency>
651 ```
652
653 b.编写登陆成功页面success.jsp
654
655 ```
656 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
657 <html>
658 <head>
659     <title>登陆成功</title>
660 </head>
661 <body>
662 <h1>登陆成功</h1>
663 </body>
664 </html>
665 ```
666
667
668
669 c.编写登陆失败页面failure.jsp
670
671 ```
672 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
673 <html>
674 <head>
675     <title>登陆失败</title>
676 </head>
677 <body>
678 <h1>登陆失败</h1>
679 </body>
680 </html>
681 ```
682
683 # Spring的两大核心技术
684
685 ## 控制反转/依赖注入
686
687 1、添加依赖
688
689 spring-core
690
691 spring-context
692
693 spring-beans
694
695 spring-expression
696
697 日志依赖
698
699 log4j
700
701 commons-logging
702
703
704
705 2、编写代码
706
707 验证控制反转/依赖注入
708
709 applicationContext.xml
710
711 ```xml
712 <?xml version="1.0" encoding="UTF-8"?>
713 <beans xmlns="http://www.springframework.org/schema/beans"
714        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
715        xmlns:context="http://www.springframework.org/schema/context"
716        xsi:schemaLocation="http://www.springframework.org/schema/beans
717        http://www.springframework.org/schema/beans/spring-beans.xsd
718        http://www.springframework.org/schema/context
719        https://www.springframework.org/schema/context/spring-context.xsd">
720
721     <bean id="person1" class="com.baidu.Person">
722         <property name="name" value="张三"/>
723     </bean>
724
725
726 </beans>
727 ```
728
729 person.java
730
731 ```java
732 /**
733  * @author 四两数字先生（CSDN/公众号）
734  */
735 public class Person {
736     String name;
737
738     public String getName() {
739         return name;
740     }
741
742     public void setName(String name) {
743         this.name = name;
744     }
745
746     //speak方法
747     public void speak(){
748         System.out.println(name+"speak hello world");
749     }
750 }
751
752 ```
753
754 MyTest.java
755
756 ```java
757 /**
758  * @author 四两数字先生（CSDN/公众号）
759  */
760 public class MyTest {
761
762     @Test
763     public  void test1(){
764         /**
765          * 通过代码创建对象
766          * 通过代码给属性赋值
767          */
768         //创建对象
769         Person person=new Person();
770         //给属性赋值
771         person.setName("张三");
772         //调用speak方法输出
773         person.speak();
774
775     }
776
777     @Test
778     public void test2(){
779         /**
780          * 通过spring技术之一：控制反转/依赖注入实现来实现
781          * 1  由spring容器创建对象
782          * 2  由spring容器给属性赋值
783          *
784          * 控制反转/依赖注入：
785          * 控制权正转：通过java代码创建对象和给属性赋值
786          * 控制权反转： 将创建对象和给属性赋值的权利反转给spring容器；
787          * 控制反转就等价于依赖注入
788          *
789          */
790         //调用speak方法输出
791         //通过spring配置文件,获得对象ApplicationContext
792         ApplicationContext applicationContext =
793                 new ClassPathXmlApplicationContext
794                         ("applicationContext.xml");
795
796         Person person1 = (Person) applicationContext.getBean("person1");
797
798         person1.speak();
799
800     }
801 }
802
803 ```
804
805 ## 面向切面编程技术
806
807 在编写代码的过程中，有些代码和业务相关（比如增删改查功能），有些代码和业务没有直接关系，但是是必不可少（日志，安全权限等）
808
809 1、添加依赖
810
811 spring-core
812
813 spring-context
814
815 spring-beans
816
817 spring-expression
818
819 **和日志相关**
820
821 commons-logging
822
823 log4j
824
825 **和aop相关**
826
827 spring-aop
828
829 aopalliance
830
831 aspectjweave
832
833 # springMvc
834
835 ## **参数传递（View to Controller）**
836
837 ### **url含参传递（@RequestParam）**
838
839 ```java
840 @Controller
841 public class IndexController{
842
843      @RequestMapping(“/welcome”)
844
845      public String index(@RequestParam(value=”username”, required=false)String username){
846
847
848 }
849
850 }
851 ```
852
853 ### **更精确的url含参传递(@RequestMapping)**
854
855 注意：http请求信息不仅不含请求url地址，还包含请求方法/请求参数/请求头
856
857 ```
858 @RequestMapping(value=”/welcome”, method=RequestMethod.GET, params=”username”)
859
860 public String index(@RequestParam String username){
861
862    logger.info(username);
863
864    return “index”;
865
866 }
867 ```
868
869 ## **参数传递（Controller to View）**
870
871 ### **ModelAndView实现参数传递**
872
873 ```java
874 Controller
875
876    @Request Mapping(“/welcome”)
877 public String index(@RequestParam(value=”username”,required=false) String username){
878          logger.info();
879         ModelAndView m=new ModelAndView();
880          m.addObject(username);
881          m.setViewName(“index”);
882          Return m;
883 }
884 ```
885
886 index.jsp 获得容器中的参数
887
888 ```html
889  <h2 >modelAndView(key:default)--->${string}</h2>
890 ```
891
892 ### **Model实现参数传递**
893
894 需要使用到el表达式需要添加什么？
895
896 web.xml需要修改？
897
898 添加 web-app 后面的属性内容才能支持el表达式
899
900 ```xml
901 <?xml version="1.0" encoding="UTF-8"?>
902
903 <web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
904 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
905 http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
906 version="3.0">
907 </web-app>
908 ```
909
910 Controller层
911
912 ```java
913   @RequestMapping(“/welcome”)
914 public String index(@RequestParam String username, Model model){
915 logger.info();
916
917        //1
918       model.addAttribute(“username”,username);
919
920        //2
921         model.addAttribute(username);
922
923        //3
924        User user= new User();
925        user.setUserName(username);                  model.addAttribute(“currentUserName”,user);
926  Return “index”;
927
928 }
929 ```
930
931 Index.jsp
932
933 ```html
934 <h1>model(key:username)---->  ${username}</h1>
935
936 <h1>model(key:default)------->  ${string}</h1>
937
938 <h1>model(key:currentUserName)---->${currentUseName.userName}</h1>
939 ```
940
941 ### **Map实现参数传递**
942
943 Controller
944
945 注意：Map<String,Object> model 必须以形参的方式引入
946
947 ```java
948 @RequestMapping(“/welcome”)
949   public String index(@RequestParam(value=”username”)  String username,Map<String,Object> map){
950 map.put(“username”,username);
951 return “index”;
952 }
953 ```
954
955 # Ajax技术
956
957 1 register.jsp
958
959 ```java
960 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
961 <html>
962 <head>
963     <title>注册</title>
964     <script src="statics/js/jquery-3.4.1.js"></script>
965     <script>
966         $(document).ready(function () {
967             $("#name").blur(function () {
968                 var name=this.value;
969                 if(name==null || name==""){
970                     $("#nameDiv").html("用户名不能为空");
971                 }else {
972                     $.ajax({
973
974                         "url" :"<%=request.getContextPath()%>/AjaxServlet",//action
975                         "data":"name1="+name, //含参 &name=lisi
976                         "type" :"get",//method 请求方式
977
978                         "success":callBack,//返回结果成功,写函数名
979                         "dataType":"text",//返回的数据类型
980                         "error": function () {
981                             alert("返回结果失败");
982                         }
983                     });
984
985                     function callBack(data) {//返回的结果
986                         if(data=="true"){//== 字符串
987                             $("#nameDiv").html("该用户已被使用");
988                         }else{
989                             $("#nameDiv").html("该用户可以使用");
990                         }
991                     }
992                 }
993             });
994         });
995     </script>
996 </head>
997 <body>
998 <form action="" method="">
999     <%--请求方式
1000         get  表单中参数会出现url路径中
1001         post 表单的参数不会出现在url路径中，更加安全
1002     --%>
1003     <h1>注册页面</h1>
1004     姓名：<input type="text" name="username" value="" id="name">
1005             <div id="nameDiv"></div>
1006     密码：<input type="password" name="password" value="">
1007     再次确认密码：<input type="password" name="password" value="">
1008     <input type="submit" name="register" value="注册">
1009 </form>
1010 </body>
1011 </html>
1012 ```
1013
1014 2 AjaxServlet.jsp
1015
1016 ```java
1017 package com.baidu.servlet;
1018
1019 import com.baidu.service.UserService;
1020 import com.baidu.service.UserServiceImpl;
1021
1022 import javax.servlet.ServletException;
1023 import javax.servlet.annotation.WebServlet;
1024 import javax.servlet.http.HttpServlet;
1025 import javax.servlet.http.HttpServletRequest;
1026 import javax.servlet.http.HttpServletResponse;
1027 import java.io.IOException;
1028 import java.io.PrintWriter;
1029
1030 /**
1031  * @author 四两数字先生（CSDN/公众号）
1032  */
1033 public class AjaxServlet extends HttpServlet {
1034
1035
1036     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
1037         this.doGet(request,response);
1038     }
1039
1040     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
1041         //编写代码
1042         //防止中文乱码
1043         request.setCharacterEncoding("utf-8");
1044         String name = request.getParameter("name1");//name是哪里
1045         boolean  flag=false;
1046
1047         //模拟数据库：假设数据库中存在用户名"admin"
1048         if(name.equals("admin")){
1049                 flag=true;//boolean 型返回前端时自动变成字符串"true"
1050         }
1051
1052         response.setContentType("text/html;charset=utf-8");
1053         PrintWriter writer = response.getWriter();
1054         writer.print(flag);//将flag返回给前端
1055         writer.flush();
1056         writer.close();
1057
1058     }
1059 }
1060 ```
1061
1062 3 web.xml
1063
1064 ```xml
1065 <!DOCTYPE web-app PUBLIC
1066  "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
1067  "http://java.sun.com/dtd/web-app_2_3.dtd" >
1068
1069 <web-app
1070         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1071         xmlns="http://java.sun.com/xml/ns/javaee"
1072         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
1073         id="WebApp_ID" version="3.0"
1074 >
1075   <display-name>Archetype Created Web Application</display-name>
1076
1077   <servlet>
1078     <servlet-name>AjaxServlet</servlet-name>
1079     <servlet-class>com.baidu.servlet.AjaxServlet</servlet-class>
1080   </servlet>
1081   <servlet-mapping>
1082     <servlet-name>AjaxServlet</servlet-name>
1083     <url-pattern>/AjaxServlet</url-pattern>
1084   </servlet-mapping>
1085
1086   <servlet>
1087     <servlet-name>MyServlet</servlet-name>
1088     <servlet-class>com.baidu.servlet.MyServlet</servlet-class>
1089   </servlet>
1090   <servlet-mapping>
1091     <servlet-name>MyServlet</servlet-name>
1092     <url-pattern>/MyServlet</url-pattern>
1093   </servlet-mapping>
1094 </web-app>
1095 ```
1096
1097 # Json格式数据
1098
1099 ```html
1100 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
1101 <html>
1102 <head>
1103     <title>Title</title>
1104     <script src="statics/js/jquery-3.4.1.js"></script>
1105     <script>
1106         $(document).ready(function() {
1107
1108             //1、定义JSON格式的user对象，并在div中输出
1109             var user = {
1110                 "id" : 1,
1111                 "name" : "张三",
1112                 "pwd" : "000"
1113             };
1114             $("#objectDiv").append("ID：" + user.id + "<br>")
1115                 .append("用户名：" + user.name + "<br>")
1116                 .append("密码：" + user.pwd + "<br>");
1117
1118             //2、定义JSON格式的字符串数组，在ul中输出
1119             var ary = [ "中", "美", "俄" ];
1120             var $ary = $(ary);
1121             var $ul = $("#arrayUl"); // 展示数据的ul元素
1122             $ary.each(function() {
1123                 $ul.append("<li>"+this+"</li>");
1124             });
1125
1126             //3、定义JSON格式的字符串数组，在select中输出
1127             var $sel = $("#arraySel"); // 展示数据的select元素
1128             $ary.each(function(i) {//index 索引
1129                 /**
1130                  * <select name=“国籍” id=“arraySel”>
1131                  *     <option value=1>中</option>
1132                  *     <option value=2>美</option>
1133                  *     <option value=3>俄</option>
1134                  * </select>
1135                  */
1136                 //"<option value='"+(i+1)+"'>"
1137                 $sel.append("<option value='"+(i+1)+"'>"+this+"</option>");
1138             });
1139
1140             //4、定义JSON格式的user对象数组，并使用<table>输出
1141             var userArray = [ {
1142                 "id" : 2,
1143                 "name" : "admin",
1144                 "pwd" : "123"
1145             }, {
1146                 "id" : 3,
1147                 "name" : "詹姆斯",
1148                 "pwd" : "11111"
1149             }, {
1150                 "id" : 4,
1151                 "name" : "梅西",
1152                 "pwd" : "6666"
1153             } ];
1154             /**<div id="objectArrayDiv">
1155              * <table border='1'>
1156              *     <tr><td>ID</td><td>用户名</td><td>密码</td></tr>
1157              *     <tr><td>2</td><td>admin</td><td>123</td></tr>
1158              *     <tr><td>3</td><td>詹姆斯</td><td>11111</td></tr>
1159              *     <tr><td>4</td><td>梅西</td><td>666</td></tr>
1160              *  </table>
1161              *  <div>
1162              *   我是中国人我爱中国我爱人民人民爱我
1163              */
1164             var $table = $("<table border='1'></table>").append(
1165                 "<tr><td>ID</td><td>用户名</td><td>密码</td></tr>");
1166             $(userArray).each(function() {
1167                 $table.append("<tr><td>" + this.id + "</td><td>"
1168                     + this.name + "</td><td>"
1169                     + this.pwd + "</td></tr>");
1170             });
1171             $("#objectArrayDiv").append($table);
1172
1173         });
1174     </script>
1175 </head>
1176 <body>
1177     <%--div中呈现普通对象--%>
1178     <div id="objectDiv"></div>
1179     <%--无序列表形式呈现数组--%>
1180     <div>
1181         <ul id="arrayUl">
1182
1183         </ul>
1184     </div>
1185     <%--下拉列表形式呈现数组--%>
1186     <div>
1187         <select id="arraySel"></select>
1188     </div>
1189     <%--表格形式呈现对象数组--%>
1190     <div id="objectArrayDiv">
1191
1192     </div>
1193 </body>
1194 </html>
1195 ```
1196
1197 # SpringMVC参数传递
1198
1199 ```java
1200 @Controller
1201 @RequestMapping("/user")
1202 public class UserController {
1203
1204     //private UserService userService=new UserServiceImpl();
1205     @Resource  //自动装配
1206     private UserService userService;
1207
1208     //无参数的url ：localhost:8080/项目名/user/index
1209     @RequestMapping("/index")
1210     public String index(){
1211         return "index";//index就是逻辑视图名
1212     }
1213     //含参的url:localhost:8080/项目名/user/login?xiaogou=lisi&xiaomao=lisi
1214     @RequestMapping(value = "/login")
1215     public String login(@RequestParam(value = "xiaogou",required = false) String username,
1216                         @RequestParam(value = "xiaomao",required = false) String password){
1217         boolean flag = this.userService.login(username, password);
1218         if(flag){//用户存在
1219             return "success";
1220              }
1221         return "failure";
1222     }
1223     //含参的url:localhost:8080/项目名/login?xiaogou=lisi&xiaomao=lisi
1224     //更精确的含参url：method = RequestMethod.POST
1225     @RequestMapping(value = "/login1" ,method = RequestMethod.POST)
1226     public String login1(@RequestParam(value = "xiaogou",required = false) String username,
1227                          @RequestParam(value = "xiaomao",required = false) String password){
1228         boolean flag = this.userService.login(username, password);
1229         if(flag){//用户存在
1230             return "success";
1231         }
1232         return "failure";
1233     }
1234
1235     //Controller层传递到View
1236     //1 ModelAndView 作为返回对象
1237     @RequestMapping("/index1")
1238     public ModelAndView index1(){
1239         User user = new User();
1240         user.setId(1);
1241         user.setUsername("zhangsan");
1242         user.setPassword("123456");
1243
1244         ModelAndView modelAndView = new ModelAndView();
1245         //存放数据
1246         modelAndView.addObject("user",user);//key-value
1247         //设置逻辑视图名
1248         modelAndView.setViewName("nankeyuan");
1249         return modelAndView;
1250     }
1251
1252 //Model 作为一个容器，保存数据
1253     @RequestMapping("/index2")
1254     public String index2(Model model){
1255         model.addAttribute("str","hello model");
1256         //字符串类型 --key:string
1257         model.addAttribute("hello model2");
1258         return "nankeyuan";
1259     }
1260
1261     //Map作为容器，保存数据
1262     @RequestMapping("/index3")
1263     public String index3(Map<String,Object> map){
1264         map.put("mapStr","map demo");
1265         return "nankeyuan";
1266     }
1267 }
1268
1269 ```
1270
1271 # 字符乱码过滤器
1272
1273 web.xml
1274
1275 ```
1276 <filter>
1277     <filter-name>characterFilter</filter-name>
1278     <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
1279     <!-- 设置过滤器中的属性值 -->
1280     <init-param>
1281       <param-name>encoding</param-name>
1282       <param-value>UTF-8</param-value>
1283     </init-param>
1284     <!-- 启动过滤器 -->
1285     <init-param>
1286       <param-name>forceEncoding</param-name>
1287       <param-value>true</param-value>
1288     </init-param>
1289   </filter>
1290   <filter-mapping>
1291     <filter-name>characterFilter</filter-name>
1292     <!--表示项目名下的所有url都被拦截过滤-->
1293     <url-pattern>/*</url-pattern>
1294   </filter-mapping>
1295
1296 ```
1297
1298 ## Restful风格路径
1299
1300 ```java
1301     //url中含参传递  restful风格路径
1302     //localhost:8080/userPro-ssm/user/index6/lisi   等价(?username=lisi)
1303     @RequestMapping("/index6/{username}")
1304     public String index6(@PathVariable(name = "username") String username){
1305         System.out.println("用户名为"+username);
1306         return "nankeyuan";
1307     }
1308 ```
1309
1310