框架技术与应用开发期末速成

spring

Spring简介

    Spring是个java企业级应用的开源开发框架。Spring主要用来开发web应用是一个轻量级的控制反转(IOC)和面向切面(AOP)的容器框架。

Spring体系结构

核心容器:

Core模块
提供了框架的基本组成部分，包括TOC和依赖注入功能

Beans模块
提供 BeanFactory，它是一个工厂模式的复杂实现

Context模块
它是访问定义和配置的任何对象的媒介。ApplicationContext接口是其重点

SpEL模块
表达式语言

 Web层

web模块
提供了基本的面向web的集成功能，例如多个文件上传的功能和使用servlet监听器和初始化IOC容器

web-MVC模块
包含Spring的模型-视图-控制器(MVC)，实现了web应用程序

websocket模块
为webSocket-based提供了支持，而且在web应用程序中提供了客户端和服务器端之间通信的两种方式

Portlet模块
提供了在portlet环境中实现MVC

 数据访问/集成

JDBC模块
提供了删除冗余的JDBC相关编码的JDBC抽象层

ORM模块
为流行的对象关系映射API，包括JPA，JDO,Hibernate和iBatis,提供了集成层
OXM模块

提供了抽象层，它支持对JAXB,Castor,XMLBeans，JiBx和Xstream 的对象/XML映射实现Transactions模块
为实现特殊接口的类及所有的POJO支持编程式和声明式事务管理

JMS模块
Java消息服务，包含生产和消费的信息的功能

其他模块

AOP模块
提供了面向切面的编程实现，允许你定义方法拦截器和切入点Aspects模块
提供了与AspectJ的集成，这是一个功能强大且成熟的面向切面Messaging模块
处理来自websocket客户端的信息

Spring特征

三大特征:AOP、IOC、DI。

IOC : 控制反转
DI :依赖注入。
AOP : 面向切面编程

 Spring loC/DI概述

loc(控制反转)
使用目的:降低耦合度

正向控制:若要使用某个对象，需要自己去负责对象的创建。

反向控制:若要使用某个对象，只需要从 spring 容器中获取需要使用的对象，不关心对象的创建过程，也就是把创建对象的控制权反转给了spring框架。

DI的方式(依赖注入)

对象只提供普通的方法，容 权负责组件的装配，它会把符合依赖关系的对象通过属性(Javabean中的setter)或者是构造 传递给需要的对象。

 Spring loc容器

I0C容器负责对象的创建、初始化等一系列工作，被创建或被管理的对象在IOC容器中统称为Bean。

常见的IoC容器实现方式包括 BeanFactory和ApplicationContext。
(1) BeanFactory: Spring内部使用的接口，不提倡开发人员使用。特点: 加载配置文件时不会创建对象，获取对象时才会创建对象。
(2) ApplicationContext: BeanFactory的子接口，提供了更多更强大的功能，一般由开发人员使用。特点: 加载配置文件时会把配置文件里的对象进行创建。

Spring框架入门案例

引入依赖到pom.xml中

<dependenctes>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>6.0.9</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>6.0.9</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>6.0.9</version>
    </dependency>
    <dependency>
        <groupId>commons-1ogging</groupId>
        <artifactId>commons-Togging</artifactId>
        <version>1.2</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.2.8</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>6.0.9</version>
    </dependency>
</dependencies>

第一步：创建Maven 项目

第二步：创建Java和resource文件夹

第三步：点击install安装Maven

第一种：set方法注入

创建Book类

public class Book {

    private String bookName：

    private double price;

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }
    
    public void setPrice(double price) {
    this.price = price;
    }
   
    public void show(string bookName,double price){
        System.out.println("书名:"+bookName+" 价格:"+price);
    }
}

编写applicationContext.xml

<bean id="book" class="com.wuji.Book">
     <property name="bookName" value="aaa"></property>
     <property name="price" value="19999.11"></property>
</bean>
</beans>

编写测试类

public class client1 {
    public static void main(String[] args) {    
    //com.wuji.Book book=new com.wuji.Book();
    //book.setBookName("aaa");
    //book.setPrice(11.11);
    //book.show();

    ApplicationContext context=new ClassPathXmlApplicationContext;
    Book book = context.getBean( "book",Book.class );   
    book.show();
    }
}

通过控制反转交给spring容器去处理

第二种 有参构造方法注入

public class Book {
    private String bookName;
    private double price

    public Book(string bookName,double price) {
        this .bookName = bookName;    
        this.price = price;
    }
    public void show(){
        System.out.printIn(bookName+":"+price) ;
    }                                                            
}

<bean id="book”class="com.wuji.Book">
    <constructor-arg name="bookName”value="aaa"></constructor-arg>
    <constructor-arg name="price" value="199.9"></constructor-arg>
</bean>                                                                                        

 第三种：注解注入

首先添加依赖

<bean id="cat” class="com.Cat"></bean>
<bean id="dog" class="com.Dog"></bean>
<bean id="animal" class="com.Animal"></bean><context:annotation-config></context:annotation-config>
</beans>

创建一个cat dog 以及 animal类

public class Animal {

    @Autowired
    private Cat cat;
    @Autowired
    private Dog dog;
    public Cat getCat() {
        return cat;
    }
    public Dog getDog() {
    return dog;
    }
}

@Autowried：在属性上面加,自动按照类型注入，不关心bean的id，只要有唯一的类型匹配就可以注入成功。无需s et方法。如果注入的bean在容器中类型不唯一时，它会把变量名作为bean的id，然后在容器中查找，找到则注入成功。如果没有找到一致的bean id则报错。

如果类型有多个，可以用@Qualifier

如

<bean id="cat1” class="com.Cat"></bean>
<bean id="cat2”class="com.Cat"></bean>
<bean id="dog1" class="com.Dog"></bean>
<bean id="dog2" class="com.Dog"></bean>
<bean id="animal" class="com.Animal"></bean><context:annotation-config></context:annotation-config>
</beans>

public class Animal {

    @Autowired
    @Qualifire(value = "cat1")
    private Cat cat;
    @Autowired
    @Qualifire(value = "dog1")
    private Dog dog;
    public Cat getCat() {
        return cat;
    }
    public Dog getDog() {
    return dog;
    }
}

@Qualifier:在自动搜索类型的基础上，再按照bean的id注入，属性value：用于指定bean的id。在给类成员注入数据时，不能独立使用，但在给方法的行参注入数据时，可以独立使用

既能按名称又能按类型来的注解？

@Resouce(name="")

@Componet 描述spring中的一个bean (使用后可以将xml中的bean去掉)

@Repository 将数据访问层 (Dao层) 的类标识为Spring中的bean

@service 将业务层 (Service层) 的类标识为Spring中的bean

@Contro11er 将控制层的类标识为Spring中的bean

spring的Bean

Bean的作用域

singleton: 单例模式: IOC容器中只会存在一个bean实例，无论多少bean引用它，始终指向相同的对象

prototype: 原型模式: IOC容器可以同时存在多个实例，当程序去获取bean时可创建出一个新的实例

request: 在一次Http请求中，容器会返回该Bean的同一实例。而对不同的Http请求则会产生新的Bean，而且该bean仅在当前Http Request内有效。
session: 在一次Http Session中，容器会返回该Bean的同一实例。而对不同的Session请求则会创建新的实例，该bean
实例仅在当前Session内有效。

global Session: 在一个全局的Http Session中，容器会返回该Bean的同一个实例，仅在使用portlet context时有效。

spring的AOP

AOP的简介

(Aspect oriented Programming)中文翻译过来是 面向切面编程底层实现也是基于 动态代理 完成的。

AOP术语

连接点 (JointPoint ):有可能调用AOP的地方叫做 连接点提供一组规则 来匹配Join Point
切点 ( PointCut):
通知 (Advice ):
切面(ASPECT):
切面的工作被称之为通知。
由切点 (Pointcut)和通知 (Advice) 组成

  AOP的实现方式

1.添加 SpringAOP 框架支持
2.定义切面和切点
3.定义通知

使用AOP织入，需要导入一个依赖包                                                                                                                                                        

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>

UserSerivce接口

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void select();
}

 UserServicelmpl实现类

public class UserServiceImpl implements UserService {
    @Override
    public void add() {System.out.println(“增加了一个用户");
    @Override
    public void delete() {System.out.println("删除了一个用户");
    @Override
    public void update() {System.out.println("更新了一个用户");
    @Override
    public void select() {System.out.println("查询了一个用户");
}

 例如，现在要在查询方法之前做一个预处理，在完成之后也做一个预处理

定义切面和切点

public class MyPointCut {
    public void before(){
        System.out.println("=========方法执行前 预处理=========");
    }
    public void after(){
        System.out.println("=========方法执行后 执行完毕=========);
    }
}

<bean id="userService" class="com.service.impl.UserServiceImpl"></bean>
<bean id="mypt"class="com.pointCut.MyPointCut"></bean>
<aop:config>
定义切面
    <aop;aspect ref="mypt">

切点
    <aop:pointcut id="point"                 expression="execution(voidcom.service,impl.UserServiceImpl.select())"/>
通知
    <aop;before method="before" pointcut-ref="point"></aop:before>
    <aop:after method-"after" pointcut-ref="point"></aop;after>
    </aop:aspect></aop:config>
</beans>

     AOP实现注解

  在UserServicelmpl实现类 开头加上 @Service

给MyPoint添加注解

@Aspect
@Component
public class MyPointCut {
    @Before("execution(void com.service.impl).select()")
    public void before(){
        System.out.println("=========方法执行前 预处理=========");
    }
    @After("execution(void com.service.impl).select()")
    public void after(){
        System.out.println("=========方法执行后 执行完毕=========);
    }
}

   测试

public class client1 {
    public static void main(string[] args) {

ApplicationContext context=new ClassPathXmlApplicationContext(configlocation:"applicationContext.xml");
UserService userService = context.getBean( s: "userService", UserService.class);
System.out.printIn(userService.getClass());
userService.select();
}
}

通知类型                                                                                                                       
1 前置通知使用 @Before: 通知方法会在目标方法调用之前执行
2 后置通知使用 @After: 通知方法会在目标方法返回或者抛出异常后调用
3 返回之后通知使用 @AfterReturning: 通知方法会在目标方法返回后调用
4 抛异常后通知使用 @AfterThrowing: 通知方法会在目标方法抛出异常后调用5 环绕通知使用 @Around: 通知包裹了被通知的方法，在被通知的方法通知之前和调用之后执行自定义的行                                                                                                                                                       

spring整合mybits

1.引入依赖

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.</version>
</dependency>

    2.MybatisConfig;java

public class MybatisConfig {
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSourcedataSource){
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        ssfb.setTypeAliasesPackage("com.itheima.domain");
        ssfb.setDataSource(dataSource);
        return ssfb;
    }
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
    msc.setBasePackage("com.itheima.dao");
    return msc;
    }
}

       3.测试类

public class client{
    public static void main(String[] args) {
        ApplicationContext ctx = newAnnotationConfigApplicationContext(SpringConfig.class);
        AccountService accountService = ctx.getBean(AccountService.class);
        Account ac = accountService.findById(2);
        System.out.printIn(ac);
    }
}

springMVC                                                                                            

SpringMVC概述
SpringMVC技术与Servlet技术功能等同，均属于web层开发技术

 SpringMVC是一种基于Java实现MVC模型的轻量级Web框架优点
使用简单，开发便捷 (相比于Servlet)
灵活性强

SpringMVC入门案例

1.使用SpringMVC技术需要先导入SpringMVC坐标与Servlet坐标

<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax,servlet-api</artifactId>
<version>3.1.</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>

2.创建SpringMVC控制器类 (等同于Servlet功能）

@Controller
public class UserController {
    @RequestMapping("/save" )
    @ResponseBody
    public String save(){
    System.out.println("user save ...");
    return "{'info':'springmvc'}";
    }
}

3.初始化SpringMVC环境 (同Spring环境) ，设定SpringMVC加载对应的bean

@Configuration
@ComponentScan("com.itheima.controller")
public class SpringMvcConfig {
}

 4.初始化Servlet容器，加载SpringMVC环境，并设置SpringMVC技术处理的请求

public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {        protected WebApplicationContext createServletApplicationContext(){
AnnotationConfigWebApplicationContext ctx = new AnnotationConfigwebApplicationContext();
ctx.register(SpringMvcConfig.class);
return ctx;
}
protected String[] getServletMappings() {
    return new String[]{"/" };
}
protected WebApplicationContext createRootApplicationContext() {
return null;
}
}

 UserController.java

//2.定义controller
//2.1使用@ControLler定义bean
@Controller
public class UserController {
//2.2设置当前操作的访问路径
    @RequestMapping(~"/save")
//2.3设置当前操作的返回值类型
    @ResponseBody
    public String save(){
    System.out.println("user save...");
    return "{'module':'springmvc'}";
    }
}

配置类

//3.创建springmvc的配置文件，加裁controLLer对应的bean
@Configuration 
@ComponentScan("com.itheima.controller")
public class SpringMvcConfig {
}

U+实验一测试

.Spring IoC属性注入使用set方法注入，

 

<  ①            ②       ="   ③     "   value="数据结构"/>

 1.property  2.name 3.bookname

2.  使用有参数构造注入

   

                 <    ④           ⑤         ="   ⑥       "   value="数据结构"/>

 4.constructor-arg  5.name  6.bookname

 

3.  注入对象类型属性

public class UserServiceImpl1 implements IUserService {

   private IUserDao userDao;

    public void setUserDao(IUserDao userDao) {

      this.userDao = userDao;

   }

    。。。。

}

<bean id="userService" class="nuc.edu.cn.dao.service.impl.UserServiceImpl">

     <   ⑦             ⑧       ="userDao"    ⑨        ="userDao"/>

 </bean> 

 <bean id="userDao"class="nuc.edu.cn.dao.impl.UserDaoImpl">

 </bean>

7.property 8.name  9.ref

4.    注解注入属性

public class UserServiceImpl1 implements IUserService {

      ⑩          

   private IUserDao userDao;

    @Override

       public void saveCustom(String arg) {

      。。。。

}

10.@Autowired

自动按照类型注入，不关心bean的id，只要有唯一的类型匹配就可以注入成功。无需s et方法。如果注入的bean在容器中类型不唯一时，它会把变量名作为bean的id，然后在容器中查找，找到则注入成功。如果没有找到一致的bean id则报错。

U+实验二测试

以下web应用

URL地址输入：http://localhost:8080/test/hello1

页面输出字符串“Hello Spring Boot!”

@Controller

@RequestMapping("/test") 

public class HelloController {

    //注解用于处理请求地址映射

                  ①   @RequestMapping("/hello1")    

//响应为JSON数据集

                  ②  @ResponseBody     

        public String hello() { 

             return "Hello Spring Boot!"; 

       } 

    }

以下web应用  控制类代码 调用业务层实现图书信息查询，添加。

@Controller

@RequestMapping("book")

public class UserController {

              ③  @Autowired      

   private IUserService userService;

  /**

   * 1.按bookId查询，查询bookId的值为“001”的图书，显示结果JSON格式

*   请写出URL地址：http://localhost:8080/     ④ book/getById?bookId=001     

*/

  @RequestMapping("getById")

  @ResponseBody

  public Book getBookById(Integer bookId) {

     Book book = bookService.getBook(bookId);

     return book;

  }

  /**

   * 2. 按bookId查询，显示查询结果JSP视图中，

*     jsp页面路径book/details.jsp 

   */

  @RequestMapping("/getByIdForJSP")

  public         ⑤  ModelAndView   getBookById1(Integer id) {

     Book book= bookService.getBook(    ⑥   id );

     ModelAndView mv = new ModelAndView();

     mv.addObject("book1",   ⑦book   );

     mv.setViewName("⑧      book           ");

     // 返回模型和视图

     return   ⑨ mv                ;

  }

  /**

   * 3. 按bookId查询，查询bookId为"003"的图书信息

*    请写出URL地址：http://localhost:8080/     ⑩ book/getBookById/003     

   */                         

  @GetMapping("/getBookById/{id}")

  @ResponseBody

  public User get(   ⑾   @PathVariable         Integer id) {

  return bookService.getBook(          ⑿  id   );

  }

/**

   * 4.如果获取图书编号为“bookId3“且图书名称为”bookName3”的图书信息,查询结果为多条数据

   

   * 请写出URL地址：

* http://localhost:8080/    ⒀     book/list/bookId3/bookName3  

  */

  @RequestMapping("list/{bookId1}/{bookName1}")

  @ResponseBody

  public List<Book> list1(   ⒁  @PathVariable("bookId1")  String bookId,  ⒂@PathVariable("bookName1")        String bookName) {

      ⒃  Book&gt   books = BookService.findBooks(bookId, bookName);

     return books;

  }

/**

        * 5. 使用@RequestParam获取参数，按bookId与bookName查询信息

* 如果bookId参数必须填写，bookName参数可填可不填

*  /

       @RequestMapping("list2")

       @ResponseBody

       Public  Book list2(

@RequestParam(value="bookId",    ⒄ required=true  ) String bookId,

                     @RequestParam(value="bookName",  18required=false     ) String bookName) {

              Book book= userService.findBook(bookId, bookName);

              return book;

       }

/**

        * 6  .打开“新增图书”请求页面, 页面显示用户信息文本框 return 字符串，指向页面

        * URL地址：http://localhost:8080/⒆   book/add            

        */

       @RequestMapping("add")

       public  String add( ) {

              return "/book/add";

       }

/**

        * 7. 新增图书

        *前端将数据转换为JSON数据后，通过HTTP请求体提交给后端。

 */

       @PostMapping("/insert")

       @ResponseBody

       public User insert(⒇   @RequestBody          Book book) {

              bookService.insertBook(book);

              return user;

       }

}

U+实验四测试

一、test数据库中t_user表结构如下：

 1） 定义实体类
package com.cn.entity
public class User {
   private Integer id;
   private String userName;
   private String note;

    setter 、getter方法
}
2）持久层 
package com.cn.dao;

/***import***/

       ①  @Mapper     
public interface IUserDao {
    public List<User> findAllUsers();
    public User getUserById(Integer uid);
    public Integer insertUser(User user);
    。。。

}
3) UserMapper.xml文件
<mapper  namespace="           ②  com.cn.dao.IUserDao       ">

   <select id="  ③   getUserById     "      parameterType="Integer"      resultType="     ④ com.cn.entity.User       ">
        select id,user_name as userName,note  from t_user   where id=       ⑤  #{id}  
   </select>
      
   <select id="    ⑥ findAllUsers  "          resultType="    ⑦com.cn.entity.User    ">

           select id,user_name as userName,note from t_user
   </select>

   <insert id="⑧   insertUser     "       parameterType="  ⑨ com.cn.entity.User   "            ⑩   useGeneratedKeys     ="true"      keyProperty="id">
           insert into t_user(user_name,note) values(#{userName},#{note})
   </insert>

</mapper>

U+实验五测试

补充完整代码：

部门表和员工表结构如下：（一个部门有多名员工，一名员工只能属于一个部门，两表通过部门编号deptno建立连接）

1.  定义实体类

package  com.cn. pojo

  //员工实体类

   public class Emp { 

      private Integer empno; 

      private String ename; 

       …..

      private     (1)  Dept      dept;  //定义员工和部门的关系 dept为成员变量

      setter,getter 方法 

   }

package  com.cn. pojo

 //员工部门实体类

public class Dept { 

    private Integer deptno;

    private String dname; 

    private String location; 

    private     (2)  List&lt     emps;  //定义部门和员工的关系，emps为成员变量

setter,getter 方法

}

2. Dao 接口  

package com.cn.dao;

…

public interface IEmpDao { 

     public  Emp  findByEmpno(Integer empno);  //按员工编号查询员工信息及员工所属部门信息

     public  List<Emp>   findByDeptno(Integer deptno);  //根据部分编号查询员工信息

}

3.  EmpMapper.xml文件

 <mapper namespace=" com.cn.dao.IEmpDao ">

   <!—手动映射 Dept表和Java Dept类属性 -->

       <    (3)resultMap       id="empMap"    type="    (4)   com.cn.pojo.Emp  ">

             <   (5)  id     property="empno"  column="empno"/>

             <    (6)  result    property="ename" column="ename"/>

             。。。。。

             <    (7)  association    property="dept"      javaType="   (8) com.cn.pojo.Dept    ">

                  。。。。。

             </     (7)  >

       </    (3)  >

       <!--根据empno查询员工，关联Dept表 -->

       <select  id="   (9)findByEmpno  "     parameterType="Integer"       resultMap="  (10)empMap  ">

           select  *  from emp e,dept d 

           where  e.deptno=d.deptno  and e.empno=#{empno}

       </select>

        <!--根据deptno查询员工-->

        <select   …….>

              select * from emp   where deptno=#{deptno}

        </select>

</mapper>

4.  Dao 接口

  package com.cn.dao;

    …

 public interface IDeptDao {

        public Dept findByDeptno(Integer deptno);//按部门编号查询员工信息，包括员工详细信息

 }

5.  DeptMapper.xml文件

<mapper  namespace="com.cn..dao.IDeptDao">

       <resultMap  type="      (11)com.cn.pojo.Dept"   id="deptMap">

            <   (12)id      property="deptno"  column="deptno"/>

            <   (13) result     property="dname"  column="dname"/>

                    。。。

            <     (14) collection         property="   (15)emps  "       javaType="   (16)ArrayList "        ofType="   (17)   com.cn.pojo.Emp  "      column="deptno"                          select="   (18)com.cn.dao.IEmpDao.findByDeptno ">

             </   (14)    >

      </ resultMap>

     <!--根据部门编号查询员工 -->

       <select  id="   (19)findByDeptno"     parameterType="Integer"   resultMap="     (20)deptMap  ">

              select * from dept where deptno=#{deptno}

       </select>

</mapper>

Spring MVC阶段测试

以下代码清单为控制器类实现，启动Spring Boot应用后，在浏览器中输入请求URL：http://localhost:8080/user1/1，运行结果如图所示。

请补充完整代码。（注意：输入答案时区分大小写，标点符号为英文状态下输入。）

@GetMapping("（1）         ")

   //响应为JSON数据集

（2）        

   public User get(（3）         Integer id) {

      return userService.getUser(id);

   }

1、

/user1/{id} user1/{id}

2、

@ResponseBody

3、

@PathVariable("id")

 

以下代码清单实现单文件上传，运行结果如图所示，请补充完整代码。（注意：输入答案时区分大小写，标点符号为英文状态下输入。）

URL地址栏输入 http://localhost:8080/upload/page

图1  文件上传页面

图2 选择文件

图3  文件上传结果

1）上传文件JSP  /WEB-INF/jsp/file/upload.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"

   pageEncoding="UTF-8"%>

<html>

<body>

       <form method="（1）         "

               action="/upload /multipart" enctype="（2）         ">

           <input type="file" name="photo" value="请选择上传的文件" />

           <input type="submit" value="提交" />

       </form>

   </body>

</html>

1.post

2、multipart/form-data

2）文件上传控制器

package com.springmvc.chapter0320191007.controller;

（3）        

public class FileController {

（4）        

public  （5）            Map<String, Object> upload(（6）        ("photo")  （7）        photo)

{

       String path = "d:/uploaded/";//保存路径

      String filename = new SimpleDateFormat("yyyyMMddHHmmssSSS").format(new Date());

3、@Controller

4、@PostMapping("/upload/multipart")

5、@ResponseBody

6、@RequestParam

7、MultipartFile

      //获取上传文件的后缀suffix

      String suffix = photo.getOriginalFilename().substring(photo.getOriginalFilename().lastIndexOf("."));

      try {

      //Spring提供了文件操作类FileCopyUtils

          FileCopyUtils.copy(photo.getInputStream(), new FileOutputStream(path + filename + suffix));

      } catch (IOException e) {

          // TODO Auto-generated catch block

          e.printStackTrace();

          return （8）        (false, "上传失败");        

      }

          return （9）        (true, "上传成功");

}

// 处理上传文件结果

   private Map<String, Object> dealResultMap(boolean success, String msg) {

       Map<String, Object> result = new HashMap<String, Object>();

       result.put("success", success);

       result.put("msg", msg);

       return （10）        ;

   }

}

8、dealResultMap

9、dealResultMap

10、result

 

以下代码清单为拦截器的使用，请补充完整代码。（注意：输入答案时区分大小写，标点符号为英文状态下输入。）

// 自定义简单拦截器Interceptor1

public class Interceptor1 implements （1）         {

   @Override

   public boolean （2）         (HttpServletRequest request, HttpServletResponse response, Object handler)

          throws Exception {

      // TODO Auto-generated method stub

      System.out.println("处理器前方法");

      // 返回true，不会拦截后续的处理

      return true;

   }

   @Override

   public void （3）         (HttpServletRequest request, HttpServletResponse response, Object handler,

          ModelAndView modelAndView) throws Exception {

      // TODO Auto-generated method stub

      System.out.println("处理器后方法");

   }

   @Override

   public void （4）         (HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)

          throws Exception {

      // TODO Auto-generated method stub

      System.out.println("处理器完成方法");

   }

}

1、HandlerInterceptor

2、preHandle

3、postHandle

4、afterCompletion

//注册拦截器

@Configuration

@SpringBootApplication(scanBasePackages="com.springmvc.chapter0320191007")

public class App1 implements WebMvcConfigurer {

   public static void main(String[] args) {

      // TODO Auto-generated method stub

      SpringApplication.run(App1.class, args);

   }

   @Override

   public void （5）         (InterceptorRegistry registry) {

      // TODO Auto-generated method stub

      InterceptorRegistration ir=registry.addInterceptor(（6）         );

// 拦截interceptor路径下所有请求

       ir.addPathPatterns("（7）         ");

   }

}

5、addInterceptors

6、new Interceptor1( ) new Interceptor1()

7、/interceptor/*

 

1） 静态页面index.html 核心代码：

<html xmlns:th="http://www.thymeleaf.org">

<head>

。。。。。

<script type="text/javascript">

$(function(){

        $("#loginbtn").click(function(){

        var loginName = $("#loginName");

        var password = $("#password");

        var msg = "";

        if(loginName.val() == ""){

                msg = "登录名不能为空!";

                loginName.focus();

         }else if(password.val() == ""){

               msg = "密码不能为空!";

               password.focus();

         }

         if(msg != ""){

                alert(msg);

          }else{

                 $("#loginform").submit();

          }

    })

 })

</script>

</head>

<body>

<h2>用户登录</h2>

<form  action="login"  method="post"  id="loginform">

       <input  type="text" name="loginName"   id="loginName" />

       <input  type="password" name="password"  id="password" />

       <button type="button"   id="loginbtn">  登录</button>

       <button type="button"   id="registerbtn"> 注册</button>

</body>

</html>

2） 通过控制类访问index.html

package nuc.edu.cn.chapter03.controller;

/***Import***/

（1）        

public class IndexController {

   //Spring MVC会自动生成视图，并且绑定数据模型

     public String index(Model model) {

           System.out.println("IndexController index方法被调用。。。。");

           return "index";

     }

}

3）处理请求的控制类LoginController

package nuc.edu.cn.chapter03.controller;

/***Import***/

（2）        

public class LoginController {

    @PostMapping("（3）         ")

     public ModelAndView login(    （4）          String loginName,     （5）          String password,ModelAndView mv) {

         System.out.println("LoginController login方法被调用。。。");

         System.out.println("LoginController 登录名 ："+loginName+"  密码："+password);

         mv.setViewName("redirect:/main");

         return mv;

      }

}

4）处理请求的控制类 MainController

package nuc.edu.cn.chapter03.controller;

/***Import***/

@Controller

public class MainController {

       @RequestMapping("   （6）  ")

        public String main() {

        System.out.println("MainController main方法被调用。。。");

      //根据Thymeleaf默认模板，将返回resources/templates/main.html

       return   "main";

   }

}

5）静态页面main.html 核心代码：

<html xmlns:th="http://www.thymeleaf.org">

<head>

。。。。

</head>

<body>

        <a th:href=" #">测试表达式访问数据</a><br/>

        <a th:href=" #">测试条件判断</a><br/>

         <a th:href=" #">测试循环</a><br/>    

</body>

</html>

1、

@Controller

2、

@Controller

3、

/login login

4、

@RequestParam("loginName")

5、

@RequestParam("password")

6、

/main main