第一章 Java Web 技术概述 作业

1、完成课后(P28)选择题和问答题（只需完成，不需要提交）

2、Tomcat的目录结构及其用途？

bin:启动/关闭应用服务器的bat批处理命令；
conf:包含不同的配置文件。包括server.xml（Tomcat的主要配置文件）和为不同的Tomcat配置的web应用设置缺省值的文件web.xml。
server.xml可以设置端口号、设置域名或IP、默认加载的项目、请求编码
web.xml可以设置tomcat支持的文件类型
context.xml可以用来配置数据源之类的
tomcat-users.xml用来配置管理tomcat的用户与权限 lib:包含Tomcat使用的的jar包，当然也可以放你自己项目需要的jar包。Unix平台此目录下的任何文件都被加到Tomcat的classpath下。
temp: Tomcat运行过程中产生的临时文件。 Logs:存放Tomcat的日志文件。
webapps:这里就是你的项目了，你的项目可以是以文件或者jar包的方式存放在这个目录里。
work：work目录用来存放tomcat在运行时的编译后文件，例如JSP编译后的文件。
清空work目录，然后重启tomcat，可以达到清除缓存的作用。

5、动态网页和静态网页的区别？

静态页面是指存放在服务器中的已经提前编写好的页面，只需客户端发起请求就可以返回的页面，而动态页面则是可根据需求动态生成页面。程序是否在服务器端运行，是重要标志。在服务器端运行的程序、网页、组件，属于动态网页，它们会随不同客户、不同时间，返回不同的网页，例如ASP、PHP、JSP、ASP.net、CGI等。运行于客户端的程序、网页、插件、组件，属于静态网页，例如html页、Flash、JavaScript、VBScript等等，它们是永远不变的。

6、简述如何配置Tomcat服务，实现多主机、多端口以及同一主机的多端口访问？

多端口：编辑server.xml文件，在<Service></Service>标签中添加端口
多主机：编辑server.xml文件，添加一个<Servlet></Servlet>标签，然后在C盘中找到host文件在里面添加映射

第二章 Servlet核心技术 作业

2、详述Servlet生命周期。

加载和实例化Servlet，Servlet容器负责加载和实例化Servlet； 初始化Servle，Servlet 通过调用 init ()
方法进行初始化； 请求处理，Servlet 调用 service() 方法来处理客户端的请求； 服务终止，销毁Servlet，Servlet
通过调用 destroy() 方法终止。

3、get方法和post方法的异同？

两种方法都是HTTP的请求方法。
Get方法申请的资源类型是静态或者动态的，数据类型是文本，数据量一般不超过255个字符，并且数据是URL的一部分，在浏览器的地址栏中对用户可见，数据可在浏览器的URL历史中缓存。而Post方法申请的资源类型只能是动态的，数据类型为文本或者二进制数据，数据量没有限制，数据不是URl的一部分。

4、HTTP请求结构由哪些部分组成？和HTTP响应结构由哪些部分组成？请求转发与响应重定向的区别？

请求结构：请求行、请求头、请求方法
响应结构：状态行和状态码、响应头、响应数据
区别：请求转发是服务器将资源找到然后发送给客户端，而响应重定向则是服务器告诉客户端资源的URL由客户端去寻找

5、状态码404、403、500分别表示什么意思，以及如何解决？

404表示页面没有找到，需要重新检查URL、403表示禁止的页面、500表示服务器内部错误

6、分别描述通过url提交用户和密码，以及通过表单post提交用户和密码至Servlet实现用户和密码验证。

1.用URL访问Servlet:http://localhost:8080/user-login?username = admin&password = admin。这里，问号后面的内容为查询串。&连接多个参数。

2.Post请求：
		<form action = “usre-login” method = “post”>
				用户名: <input type = “text” name = “username”>
				密码：<input type = “password” name = “password”>
				<input type = “submit” value = “登录”>
		</form>

7、@WebServlet的作用？

@WebServle作用是代替web.xml中的servlet
的<servlet-mapping>元素中servlet的配置。
@WebServlet注解在应用程序启动时被web容器处理，
同期根据具体的属性配置将相应的类部署为Servlet

第三章 JSP技术基础 作业

2、JSP页面元素有哪些？各自的功能和作用是什么？

声明：声明变量和定义方法 小脚本：执行业务逻辑的java代码 表达式：用于在jsp页面输出表达式的值 指令：指定转换时向容器发出的指令
动作：向容器提供请求时的指令 El表达式：jsp2.0引进的表达式语言 注释：用于文档注释 模板文本：html标签和文本

3、JSP页面的生命周期以及执行过程？

页面转换、页面编译、加载和创建实例、调用jspInit()、调用_jspService()、调用jspDestroy()

4、小脚本中初始化和声明变量的顺序？

声明变量的顺序无关紧要，而小脚本中声明变量和初始化的顺序十分重要。

5、JSP页面有哪些隐含变量？举例描述各自的作用？

Application:引用web程序上下文
Session：引用用户会话
Request:引用页面当前的请求对象
Response：用来向客户发送一个响应
Out：引用页面输出流
Page：引用页面的servlet实例
Pagecontext：引用页面上下文
Config：引用servlet的配置对象
Exception用来处理错误

6、JSP页面有哪些作用域及作用范围？

应用作用域：应用程序被初始化后
会话作用域：同一会话的页面
页面作用域：当前页面内
请求作用域：同一请求的页面

7、JSP页面中静态包含和动态包含的区别？

静态包含是在jsp页面转换阶段将另一个文件的内容包含到当前jsp页面中。动态包含是在请求时将另一个页面的输出包含到主页面的输出中去。

8、JavaBeans规范？

定义javabeans类，需要遵循有关规定：
①javabeans应该是public类，且具有无参数的public构造方法。也可以定义带参数构造方法。
②类的成员变量一般称为属性（property）。对每个属性访问权限一般定义为private。注意：属性名必须以小写字母开头。

③每个属性通常定义两个public方法，
一个是访问方法（getter），一个是修改方法（setter），
使用他们访问和修改javabeans的属性值。
可以用Jsp标准动作<jsp:usebean
>创建jababeans类的一个实例，
>也可以在servlet中创建类的实例。Javabeans类的实例一般称为bean.
在jsp页面中使用
javabeans是通过三个jsp标准动作实现，
分别是：<jsp:useBean>动作、
<jsp:setProperty>动作、< jsp:getProperty >动作

9、描述MVC设计模式。
MVC模式又称为模型-视图-控制模式。该模式将web的组件分为模型、视图和控制器，每种组件完成各自的任务。该模型将业务逻辑和数据访问从表示层分离出来。实现MVC的一般步骤：①定义JavaBeans表示数据；②使用Servlet处理请求；③将结果存储在作用域对象中；④将请求转发到JSP页面；⑤最后在JSP页面中从JavaBeans中取出数据。

第四章 会话与文件管理 作业

2、什么是会话？

会话是客户与服务器之间的不间断的请求-响应序列。当客户向服务器发送第一个请求时就开始一个会话。对该客户之后的每个请求，服务器能够识别出请求来自于同一个客户。当客户明确结束会话或者服务器在一个预定义的时限内没从客户接收任何请求时，会话就结束了。当会话结束后，服务器就忘记了客户以及客户的请求

3、会话的管理机制？

(1)当客户向服务器发送第一个请求时，服务器就可以为该客户创建一个HttpSession会话对象，并将请求对象与该会话对象关联。服务器在创建会话对象时为其指定一个唯一标识符，称为会话ID，他可作为该客户的唯一标识。此时，该会话处于新建状态，可以使用HttpSession接口的isNew()来确定会话是否属于该状态。
(2)当服务器向客户发送响应时，服务器将该会话ID与响应数据一起发送给客户，这是通过Set-Cookie响应头实现的。
（3）客户在接收到响应后将会话ID存储在浏览器的 。当客户再次向服务器发送请求时，它使用Cookie请求头把会话ID与请求一起发送给服务器。
（4）服务器接收到请求后，从请求对象中取出会话ID，在服务器中查找之前创建的会话对象，找到后将该请求与之前创建的ID值相同的会话对象关联起来。

4、解读4.2 使用会话实现购物车运行过程（不要直接贴源码）？

1）首先获取到需要操作的商品类，并且实例一个对象
（2）先从session中取出之前保留的购物车，然后判断
（3）如果第一次操作，因为没有商品，所以需要重新创建
（4）然后购物车再添加本次操作的对象
（5）然后把新的列表添加进去

5、如何应用Cookie在客户端保存信息？

先使用Cookie类的构造方法创建一个Cookie对象，通过setXxx（）设置各种属性，通过响应对象的addCookie（cookie）把Cookie添加到响应头中去

第五章 JDBC访问数据库 作业

2、JDBC连接数据库的步骤？

（1）加载驱动程序
（2）建立连接对象
（3）创建语句对象
（4）执行语句获得结果
（5）关闭建立的对象

3、如何配置局部数据源？

在web应用程序的META-INF目录中建立一个context.xml文件。

5、如何解决Eclipse插入Mysql数据库中文乱码问题？

在数据库名后加上 ?useUnicode=true&characterEncoding=UTF-8 或者?characterEncoding=utf-8。如：jdbc:mysql://localhost/login?characterEncoding=utf-8（login是数据库的名字，连接的数据库为MySQL）

6、“com.mysql.cj.jdbc.Driver”与“com.mysql.jdbc.Driver”JDBC驱动的区别？

前者是mysql-connector-java 6及以上中的，后者是mysql-connector-java 5中的。JDBC连接Mysql6 com.mysql.cj.jdbc.Driver， 需要指定时区serverTimezone=UTC和 使用SSL （useSSL=false）。

第六章 表达式语言 作业

2、EL运算符的优势？

1能够强制转化对象
2.对类型没有强制要求
3.使用简单；

3、EL访问作用域变量的顺序是什么？

pageScope->requestScope->sessionScope->applicationScope；

4、EL如何访问JavaBeans属性，如何访问集合元素？

用点运算符
即可访问JavaBean对象的属性，
如“${employee.empName}”；用[]即可访问集合元素，如”${arrays[i]}”；

5、EL的隐含变量有哪些？

1.PageContext：页面的上下文对象；
2.PageScope：页面内属性名称所对应的值；
3.RequestScope：取得Request范围内属性名称所对应的值；
4.sessionScope：取得Session范围内的属性名称所对应的值；
5.applicationScope：取得Application范围内的属性名称所对应的值；
6.cookie：HttpServletRequest.getCookies()的返回值。

第七章 表达式语言 作业

2、如何引用JSTL，JSTL通用目的的标签有哪些，以及如何使用？

使用taglib指令来引用标签库。
<c:out>:在页面中显示内容
<c:set>:定义或者设置一个作用域变量
<c:remove>：清除一个作用域变量
<c:catch>:捕获异常

3、详述和举例自定义标签的开发步骤（不要大量复制源码，而是概述思路）。

1.创建标签处理类：实现doTag()
2.创建标签库描述文件TLD
3、简述带属性的标签和带标签体标签的开发思路。

1.带属性的：
格式为：”<prefix:tagName attrib1 = ${expression}/>”；
并且带有属性的定义好private字符串常量属性名，
并且写好一个方法public void setUser()，
并且在.tld 文件中添加<attribute></attribute>标签；

2.带标签体的标签的：在jsp文件中，doTag()方法中，加入getJspBody().invoke(null)，用于获取标签体的内容

第八章 Java Web高级应用 作业

2、详述HttpSession监听器监听请求事件的开发流程。

首先调用监听类RequestContextListener，可以直接配置在web.xml中，通过这个监听器，可以直接拿到Request上下文；这样就可以实现监听请求Request。

3、创建包含三个过滤器（firFilter、secFilter、thiFilter）的过滤器链，

firFilter、secFilter、thiFilter分别反馈客户端页面信息”This is the first filter!”、“This is the second filter!”、“This is the third filter!”。

第九章 Web安全性入门 作业

2、分别描述Basic和Form身份验证流程（尤其详述tomcat-users.xml和web.xml相关的配置）。
1.Basic：在tomcat的\conf目录下找到tomcat-users.xml文件，在其中增加；并在web,xml中写入语句，表示采用basic验证方式，并指出对于访问所在文件夹下的文件时，都需要获得角色的授权；
2.Form：首先建立一个需要输入用户名和密码的页面a.html，再建立一个出错时显示的页面error.html；然后在tomcat-users.html中设定用户账号，表示采用Form验证方式，并指出对于访问所在文件夹下的文件时，都需要获得角色的授权。

第十章 AJAX技术基础 作业

因主要涉及web前端，故无作业，考试不做要求。

第十一章 Struts 2框架基础 作业

2、描述Struts的开发框架组成。

1客户：即浏览器；
2.控制器：即Servlet；
3.逻辑控制：即动作Action；
4.模型：即应用状态，Application State；
5.视图：即JSP视图。

3、举例介绍Struts开发步骤以及需要进行哪些配置。

1.下载Struts2文件2.5.13;
2.将上述包放到项目WEB-INF->lib文件夹中；
3.在web.xml中添加一个过滤器；
4.创建一个struts.xml文件，放在JavaResource->src文件夹中；
5.创建一个action类，继承ActionSupport类；
6.Struts文件配置。

4、Struts如何使用配置文件实现用户输入校验？

1.首先创建一个需要校验的action，以登录输入校验为例，创建一个ValidateAction.java文件；
2.在相应的action层下面创建一个对应的XML文件，以类名+“-validation.xml”命名规则命名；
3.在该XML文件中，指定name为校验action类中的属性名；type设置为struts2中提供的校验组件的名字；设置各种输入元素的校验。

第十二章 Hibernate框架基础 作业

2、什么是数据持久、ORM、持久化对象？

数据持久：即将内存中的数据模型转换为存储模型，以及将存储模型转换为内存中的数据模型的统称，其中数据模型可以是任何数据结构或者对象模型，存储模型可以是关系模型、XML、二进制流等。

ORM：Object/Relation Mapping对象关系映射；

持久化对象：持久化类的实例即称为持久化对象。

3、实现Hibernate应用要进行哪些配置？

1.在hibernate.cfg.xml文件中调整字符集为UTF-8，并将mysql的my.ini文件中写入语句“character-set-server=utf8”；

2.在mysql中创建两个实体，如：Student、User表；

3.定义持久化类，例如创建Student.java文件；

4.在持久化类（如Student.java）的同一级目录下定义一个映射文件，
Student.hbm.xml；

5.编写测试程序MainApp.java。

4、Hibernate应用的运行过程？

1.应用程序先调用Configuration类，该类读取Hibernate的配置文件及映射文件中的信息，并用这些信息生成一个SessionFactory对象；
2.然后从SessionFactory对象生成一个Session对象，并用Session对象生成Transaction对象。可通过Session对象的get(), load(), save()等操作持久化对象PO；
3.如果没有异常，Transaction对象将提交这些操作结果到数据库。

附录：附上Java轻量级编程框架技术课后问题习题：

Spring IoC的基本概念
控制反转Ioc是一个抽象的概念，是用来消减计算机程序的耦合问题。
依赖注入（Dependency Injection DI）是IoC的另一种说法，是从不同的角度描述相同的概念。

• 控制反转：对象的实例不用调用者来创建，由Spring容器来创建，由Spring容器负责控制程序之间的关系，而不是由调用者直接控制。这样控制器由调用者转移到Spring容器，控制器发生了反转。这就是控制反转。
• 依赖注入：Spring容器负责将依赖对象赋值给调用者的成员变量，相当于为调用者注入它所依赖的实例，这就是Spring的依赖注入。

Bean的实例化有哪几种常见的方法？

答：构造方法实例、静态工厂实例、实例工厂实例化

简述基于注解的装配方式的基本用法。

答：创建带注解的Bean实例。然后配置注解，指定扫描包路径：<context:component-scan base-package=“Bean所在包路径” />最后测试Bean实例。

@Autowird和@Resource有什么区别？

答：

@Autowird和@Resource功能相似，都可以实现对类成员变量、方法及构造方法进行标注，完成自动装配。
@Autowired默认按照Bean的类型进行装配，如果想按照名称装配，需要和@Qualifier注解一起使用。效果等同于@Resource
@Resource注解按照名称来装载注入

. AOP（Aspect-Oriented Programming）的基本概念

AOP即面向切面编程，与OOP相辅相成。
在OOP中以类作为程序的基本单元。
在AOP中以Aspect（切面）作为基本单元。
AOP采取横向抽取机制，将分散在各个方法中的重复代码提取出来，在程序编译或运行阶段将抽取的代码应用在需要执行的地方。

Spring的事务管理’

基于底层API的编程式事务管理
基于底层API的编程式事务管理就是根据：

- PlatformTransactionManager
- TransactionDefinition
- TransactionStatus

什么是编程式事务管理？

在代码中显示调用与事务处理相关的方法，这就是编程式事务管理。当只要少数事务操作时，编程式事务管理才比较合适。

什么是声明式事务管理？

Spring的声明式事务管理是通过AOP技术实现的，其本质是对方法前后进行拦截，然后在目标方法开始之前创建或加入一个事务，在执行完目标方法之后根据情况提交或回滚事务。

Spring MVC的Controller

 RequestMapping注解类型
在RequestMapping注解语句中，
注解的value属性将请求的URI映射到方法
，value属性是RequestMapping注解的默认属性，
如果只有一个value属性，可省略该属性。
@RequestMapping注解有以下两个类型：

• 方法级别注解
  类级别注解
  在类级别注解的情况下，控制器类的所有方法都被映射为类级别的请求

拦截器

拦截器的定义
定义拦截器有两种方法：

实现HandlerInterceptor接口或继承HandlerInterceptor接口的实现类
实现WebRequestInterceptor或继承WebRequestInterceptor接口的实现类
HandlerInterceptor接口定义的3个方法：

preHandle：控制器处理请求方法前执行。返回true：向下执行，返回false：中断后续操作
postHandle：控制器的处理请求方法调用之后，解析视图之前执行。通过此方法对请求域中的模型和视图进一步修改
afterCompletion：在视图渲染结束后执行，实现资源清理、记录日志等功能

文件的上传和下载

1. 文件上传
   文件上传需要将表单的enctype配置为multipart/form-data，请求方法设置为post，使用标签上传文件。

springBoot是干嘛的？ 如何实现数据库操作的，整合了JDBC?

Spring Boot 是一个用于快速构建基于 Spring 框架的应用程序的开发框架。它通过提供开箱即用的功能和约定，简化了 Spring 应用程序的配置和部署过程，使开发者能够更专注于业务逻辑的实现。

在 Spring Boot 中，实现数据库操作可以通过整合 JDBC 来实现。JDBC（Java Database Connectivity）是 Java 提供的标准接口，用于与关系型数据库进行交互。Spring Boot 提供了对 JDBC 的自动配置和集成，使得数据库操作变得更加简单和方便。

首先，在 Spring Boot 的配置文件（如 application.properties 或 application.yml）中，可以配置数据库连接的相关信息，包括数据库的 URL、用户名、密码等。这些配置项会被 Spring Boot 自动加载，并创建一个数据源（DataSource）对象，用于管理数据库连接。

接下来，在代码中可以使用 Spring 提供的 JdbcTemplate 或 NamedParameterJdbcTemplate 来执行数据库操作。JdbcTemplate 是 Spring 提供的一个简化了 JDBC 操作的模板类，它封装了连接的获取、释放，以及异常的处理等操作。

使用 JdbcTemplate，可以通过调用其方法来执行 SQL 语句，如查询单个结果、查询多个结果、执行更新操作等。例如，可以使用 jdbcTemplate.queryForObject() 方法查询单个结果，使用 jdbcTemplate.query() 方法查询多个结果集，使用 jdbcTemplate.update() 方法执行更新操作等。

除了 JdbcTemplate，Spring Boot 还支持使用 ORM（对象关系映射）框架，如 Hibernate、MyBatis 等。这些框架可以进一步简化数据库操作，通过对象和映射配置来实现与数据库的交互。

在整合 JDBC 和数据库操作时，Spring Boot 会根据配置文件中的数据库连接信息自动创建数据源，并将其注入到需要使用数据库的组件中。开发者可以通过依赖注入的方式获取数据源，然后使用 JdbcTemplate 或其他 ORM 框架来执行数据库操作。

总而言之，Spring Boot 简化了基于 Spring 的应用程序的开发和部署过程，并通过整合 JDBC 和其他 ORM 框架来实现与关系型数据库的交互。开发者只需配置数据库连接信息，并使用提供的模板类或框架来执行数据库操作，从而更便捷地实现数据库操作。

将使用代码示例来解释如何在 Spring Boot 中实现数据库操作。

首先，我们需要在配置文件中配置数据库连接信息。假设我们使用的是 MySQL 数据库，可以在 application.properties 文件中添加以下配置：

spring.datasource.url=jdbc:mysql://localhost:3306/mydatabase
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

接下来，我们创建一个简单的实体类 User，表示用户信息：

public class User {
    private Long id;
    private String name;
    private String email;
 
    // 省略构造函数、getter 和 setter 方法
}

然后，我们创建一个 UserRepository 接口，用于定义数据库操作的方法：

public interface UserRepository {
    User findById(Long id);
    List<User> findAll();
    void save(User user);
    void update(User user);
    void delete(Long id);
}

接下来，我们使用 JdbcTemplate 来实现这个接口：

@Repository
public class JdbcUserRepository implements UserRepository {
    private final JdbcTemplate jdbcTemplate;
 
    @Autowired
    public JdbcUserRepository(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
 
    @Override
    public User findById(Long id) {
        String sql = "SELECT * FROM users WHERE id = ?";
        return jdbcTemplate.queryForObject(sql, new Object[]{id}, new UserRowMapper());
    }
 
    @Override
    public List<User> findAll() {
        String sql = "SELECT * FROM users";
        return jdbcTemplate.query(sql, new UserRowMapper());
    }
 
    @Override
    public void save(User user) {
        String sql = "INSERT INTO users (name, email) VALUES (?, ?)";
        jdbcTemplate.update(sql, user.getName(), user.getEmail());
    }
 
    @Override
    public void update(User user) {
        String sql = "UPDATE users SET name = ?, email = ? WHERE id = ?";
        jdbcTemplate.update(sql, user.getName(), user.getEmail(), user.getId());
    }
 
    @Override
    public void delete(Long id) {
        String sql = "DELETE FROM users WHERE id = ?";
        jdbcTemplate.update(sql, id);
    }
}

在上述代码中，我们使用了 jdbcTemplate.query() 和 jdbcTemplate.update() 方法来执行 SQL 查询和更新操作。同时，我们还定义了一个 UserRowMapper 类，用于将查询结果映射到 User 对象。

最后，我们可以在业务逻辑中使用 UserRepository 接口进行数据库操作：

@Service
public class UserService {
    private final UserRepository userRepository;
 
    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
 
    public User getUserById(Long id) {
        return userRepository.findById(id);
    }
 
    public List<User> getAllUsers() {
        return userRepository.findAll();
    }
 
    public void createUser(User user) {
        userRepository.save(user);
    }
 
    public void updateUser(User user) {
        userRepository.update(user);
    }
 
    public void deleteUser(Long id) {
        userRepository.delete(id);
    }
}

以上代码示例展示了如何在 Spring Boot 中使用 JdbcTemplate 实现数据库操作。通过配置数据库连接信息，创建相应的接口和实现类，并使用 JdbcTemplate 执行 SQL 语句，我们可以方便地进行数据库操作。

下面整合第一版java编程框架技术-期末复习 综合复习（11.23版本整合期末复习）

轻量级 JavaWeb 开发组合框架有哪些？⭐

答：轻量级 Java Web 开发框架通常注重简洁、高效和易于使用，适合快速开发中小型应用。以下是一些常见的轻量级 Java Web 开发组合框架： 老师主要讲了三种比较常见的整合开发的框架：

1. Spring Boot + Thymeleaf， 引擎模板来实现简单的案例，比如商品信息的修改还有员工信息表的增删改查，就是通过前端模板引擎调用接口控制层的接口实现的。不仅如此springboot应用的的初始搭建和开发过程，还内置了Tomcat服务器方便快捷。
2. springboot+jsp； 虽然现在jsp不常用甚至快被淘汰了，但是传统的jsp页面和java’web开发技术适合熟悉的jsp开发者。
3. Spring Boot + Thymeleaf + MyBatis 三者整合的页面也有相应的案例。
4. 剩下的像模板引擎加JPA/Hibernate， springboot加模板引擎加JPA，MongDb都没有讲到。

在 Maven 环境中配置本地仓库，则应在 maven 安装路径下 conf 文件夹中的 Settings.xml 文件中添加哪些标签来设置本地仓库和中央仓库。⭐⭐

答：这是老师第一节课讲的内容：就是需要在Maven环境下配置的，这个很简单，咱们本地仓库有一个setting.xml的文件，在这个文件中添加相关标签：

<settings>
  <!-- 配置本地仓库路径 -->
  <localRepository>/E:/repository</localRepository>
</settings>

这里的路径就是本地仓库路径，idea中默然加载的就是这个路径的，也可以指定本地仓库的路径。你可以将路径设置为任何你希望的位置。一般老师出题不会问这么细大致了解一下即可。

除此之外还要配置中央仓库：

<settings>
  <!-- 配置中央仓库 -->
  <mirrors>
    <mirror>
      <id>central</id>
      <mirrorOf>central</mirrorOf>
      <url>https://repo.maven.apache.org/maven2</url>
    </mirror>
  </mirrors>
</settings>

<mirrors>：定义镜像仓库。

<mirror>：定义一个镜像仓库。

<id>：镜像仓库的唯一标识。

<mirrorOf>：指定要镜像的仓库。central 表示中央仓库。

<url>：镜像仓库的 URL。

maven环境下的创建的项目可以选择那些模板？⭐⭐

IntelliJ IDEA 环境中创建的 Maven 项目的流程，特别是原型模板选择 Java 项目：org.apache.maven.archetypes:maven-archetype-quickstart JavaWeb 项目：org.apache.maven.archetypes:maven-archetype-webapp 多模块项目父模块：org.apache.maven.archetypes:maven-archetype-site-simple 以上三类原型模板的项目分别默认的打包方式（jar, war,）
咱们用的最多的模板就是quickstart-是java项目

JSP 页面代码是那两种代码组成？？⭐

答：其实JSP页面是由两种代码组成的；分别是静态内容和动态内容；静态内容就是咱们耳熟能详的HTML、CSS和js三剑客了；页面加载的时候不会变化，属于静态的；而动态内容通常是嵌入在JSP页面中的JAVA代码，根据请求参数、数据库查询结果等动态生成内容。

一个简单的实例，没时间的同学不用看直接跳过：

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
    <title>JSP 页面示例</title>
</head>
<body>
    <h1>欢迎来到 JSP 页面</h1>
    <%-- 动态内容 --%>
    <%
        String name = request.getParameter("name");
        if (name == null) {
            name = "Guest";
        }
    %>
    <p>你好, <%= name %>!</p>
</body>
</html>

一句话：静态内容：HTML 结构和样式。
动态内容：嵌入的 Java 代码，根据请求参数动态生成内容。

常用 lombok 注解及其功能(Set 方法，Get 方法，无参构造方法和全参构造方法)

答： 这个其实需要我们在pom.xml 全局配置文件中加载lombock的依赖，还需要在idea中的setting选项下的plugin
下配置相关插件，一个🌶辣椒的插件；他的@Getter和@Setter lombock注解专属的两个注解，他自动生成相对应的set和get方法对属性进行封装对外提供接口用于调用内部的属性修改等…还有@NoArgsConstructor自动生成无参构造，还有@AllArgsConstructor自动生成全参构造。如果说这些注解都不想用直接用暴力的，@Data注解自动生成全部的set，get，无参有参构造的全部方法。

Spring部分的考点⭐⭐⭐

Spring 基本用法需要添加的基础依赖

答：这哥们的一个核心的依赖就是Spring Core，这哥们提供了spring框架的核心功能，Core这个单词的意思就是核心的意思，这个依赖还包括依赖注入（DI） 和控制反转（IOC）
要说具体代码的话就是pom文件的那个

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>5.3.10</version>
</dependency>

还有一个兄弟依赖 Spring Context功能提供Spring应用上下文，支持Bean的配置和管理；

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.10</version>
</dependency>

还有一个特别重要的：Spring Beans 这哥们是提供 Spring Bean 的定义和管理功能。

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>5.3.10</version>
</dependency>

以上是 Spring 基本用法中常用的基础依赖。根据项目需求，可以选择性地添加这些依赖。通常情况下，spring-core、spring-context 和 spring-beans 是必须的，其他依赖根据具体功能需求添加。 当然还有很多，像：Spring AOP、Spring Web等等 ，考试不会考这么多，有兴趣了解即可。

Spring 基本用法（参照课堂实验 3） （1）依赖注入：ApplicationContext.xml 实现依赖注入 设值注入（类中要有 Setter 方法） 构造注入（类中要有带参数的构造方法）

答：说白了这个设值注入就是通过类的Setter方法将依赖注入到对象中；比如在业务逻辑处理层UserService类中有一个setUserDao的方法，和一个saveUser()方法，然后userdao类有一个save的方法；ApplicationContext.xml应用上下文的这个xml文件就可以用

<bean id="userDao" class="com.example.UserDao"/>

    <!-- 配置 UserService Bean，并使用设值注入 -->
    <bean id="userService" class="com.example.UserService">
        <property name="userDao" ref="userDao"/>

紧接着用创建一个Main类通过ClassPathXmlApplicationContext这个对象把配置文件xml传进来，返回一个context直接调用getbean方法，把业务逻辑处理层的userService类传进来，调用saveUser方法；这个地方有点绕，贼坑；

• 第二种就是构造注入了；这哥们其实就是通过类的构造方法将依赖注入到对象中；

<!-- 配置 UserDao Bean -->
    <bean id="userDao" class="com.example.UserDao"/>

    <!-- 配置 UserService Bean，并使用构造注入 -->
    <bean id="userService" class="com.example.UserService">
        <constructor-arg ref="userDao"/>

 <constructor-arg ref="userDao"/>  是构造注入的核心

一句话：
设值注入：通过类的 Setter 方法将依赖注入到对象中。
构造注入：通过类的构造方法将依赖注入到对象中。

（2）控制反转：在主类测试类中，创建控制反转容器，获取 bean 实例，实现 bean 实例 具有的功能。（重点理解标红的代码）⭐⭐

答： 控制反转这个哥们就是Spring 框架的核心概念之一，它将对象的创建和管理交给 Spring 容器，而不是由开发者手动创建和管理。通过控制反转，开发者可以专注于业务逻辑，而不必关心对象的创建和依赖管理。这么长考试不用背下来，写关键代码就好了：

比如如果考试出了要知道， 举个例子：

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
    public static void main(String[] args) {
        // 创建控制反转容器，加载 Spring 配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");

        // 获取 UserService Bean 实例
        UserService userService = context.getBean("userService", UserService.class);

        // 调用 UserService 的功能方法
        userService.saveUser();
    }
}

把实例的Bean 这一行代码去掉填空：

// 获取 UserService Bean 实例
        UserService userService = context.getBean("userService", UserService.class);

        // 调用 UserService 的功能方法
        userService.saveUser();

这两句是关键代码，就是直接用userService 直接调用他的saveUser方法；
UserService.java的代码：

public class UserService {
    public void saveUser() {
        System.out.println("User saved!");
    }
}

ApplicationContext.xml

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 配置 UserService Bean -->
    <bean id="userService" class="com.example.UserService"/>
</beans>

3. AOP （1）AOP 基本概念（切面 连接点 增强处理 代理对象） （2）基于代理类的 AOP 实现（重点代理 Bean 元素的声明）⭐⭐⭐

一句话：

AOP 基本概念：切面、连接点、增强处理、切入点、代理对象。
基于代理类的 AOP 实现：定义目标类、切面类，配置 Spring 容器，启用 AOP 自动代理。

考填空题的话就是考AOP的基本概念：

1. 切面（Aspect）：横切关注点的模块化，包含增强处理和切入点。
   2. 连接点（Join Point）：程序执行过程中的一个点，如方法调用。
2. 增强处理（Advice）：在特定连接点执行的代码，如前置、后置、环绕等。
   4. 切入点（Pointcut）：连接点的集合，定义哪些连接点应用增强处理。
3. 代理对象（Proxy Object）：目标对象的代理，用于执行增强处理。

<!-- 配置目标类 bean -->
 <bean id="myTestDao" class=" spring.demo.dao.impl.TestDaoImpl"/>
 <!-- 配置切面类 bean -->
  <bean id="myAspect" class="spring.demo.interceptor.MyAspect" /> <!-- 使用 Spring 代理工厂定义一个名为 testDaoProxy 的代理 --> 
  <bean id="testDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean"> <!-- 指定代理实现的接口-->
   <property name="proxyInterfaces" value=" spring.demo.dao.TestDao" /> 
   <!-- 指定目标对象 --> 
   <property name="target" ref="myTestDao" /> 
   <!-- 指定切面，织入环绕通知-->
    <property name="interceptorNames" value="myAspect"/> <!-- 指定代理方式，true 指定 CGLIB 动态代理，false 指定 JDK 动态代理 --> 
    <property name="proxyTargetClass" value="true"/> </bean>

重点理解

<property name="proxyInterfaces" value=" spring.demo.dao.TestDao" />

和

<property name="target" ref="myTestDao" />

考试就考这两句，换一下模子；

举个更简单的例子：
定义一个UserService的类，有一个saveUser方法

public class UserService {
    public void saveUser() {
        System.out.println("User saved!");
    }
}

定义切面类：LoggingAspect有一个logBefore方法

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class LoggingAspect {
    @Before("execution(* com.example.UserService.saveUser(..))")
    public void logBefore() {
        System.out.println("Before saving user...");
    }
}

然后配置 Spring 容器ApplicationContext.xml配置bean和AOP代理

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/aop
                           http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 配置 UserService Bean -->
    <bean id="userService" class="com.example.UserService"/>

    <!-- 配置 LoggingAspect Bean -->
    <bean id="loggingAspect" class="com.example.LoggingAspect"/>

    <!-- 启用 AOP 自动代理 -->
    <aop:aspectj-autoproxy/>
</beans>

最后直接在Main测试类中调用userServie的saveUser方法

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        UserService userService = context.getBean("userService", UserService.class);
        userService.saveUser();
    }
}

C、SpringBoot 部分 （重中之重）⭐⭐⭐⭐⭐

1. Spring Boot 提供的实现对 RESTful 接口的支持的常用注解及其功能

@Controller:这哥们是标识一个类位控制类，用于处理HTTP请求。
@RequestBody:将HTTP请求体中的数据绑定到方法参数。
@ResponseBody：将方法返回值作为 HTTP 响应体返回。
@RestController：组合 @Controller @ResponseBody，用于构建 RESTful Web 服务。就是可以这么理解。
@RequestMapping：映射 HTTP 请求到控制器方法，支持路径、请求方法、请求参数等配置。

2. 接口数据校验中定义实体（Bean）类，配置校验规则使用的常用注解⭐⭐⭐⭐

@NotNull：验证属性值不能为空。

@NotEmpty：验证集合、字符串或数组不能为空。

@NotBlank：验证字符串不能为空且不能只包含空白字符。

@Min 和 @Max：验证数值的最小值和最大值。

@Size：验证集合、字符串或数组的大小范围。

@Past 和 @Future：验证日期是否在过去或未来。

举个例子 更直观一点，请看代码！：

import javax.validation.constraints.Min;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;

public class User {
    @NotNull(message = "ID 不能为空")
    private Long id;

    @NotBlank(message = "用户名不能为空")
    @Size(min = 3, max = 20, message = "用户名长度必须在 3 到 20 之间")
    private String username;

    @Min(value = 18, message = "年龄必须大于等于 18")
    private int age;

    // Getter 和 Setter 方法
}

文件上传（重点单文件上传）⭐⭐⭐⭐

enctype="multipart/form-data"

这句代码必考！

接口控制层：实现文件上传方法的参数类型

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.MultipartFile;

@RestController
public class FileUploadController {

    @PostMapping("/upload")
    public String uploadFile(@RequestParam("file") MultipartFile file) {
        if (file.isEmpty()) {
            return "文件为空";
        }

        // 获取上传文件的原始文件名
        String originalFilename = file.getOriginalFilename();

        // 保存文件到服务器
        try {
            file.transferTo(new File("/path/to/save/" + originalFilename));
            return "文件上传成功";
        } catch (IOException e) {
            e.printStackTrace();
            return "文件上传失败";
        }
    }
}

 String originalFilename = file.getOriginalFilename();

这句代码必考；

定时任务设置使用的 @Scheduled 注解中的 cron 表达式表示规则⭐⭐⭐⭐

答：在 Spring Boot 中，@Scheduled 注解用于配置定时任务。cron 表达式是一种强大的时间表达式，用于指定定时任务的执行时间。以下是 cron 表达式的详细规则：

cron 表达式格式
cron 表达式由 6 或 7 个字段组成，每个字段之间用空格分隔：

秒 分 时 日 月 周 [年]

• 秒（0-59）
• 分（0-59）
• 时（0-23）
• 日（1-31）
• 月（1-12 或 JAN-DEC）
• 周（1-7 或 SUN-SAT）
• 年（可选，1970-2099）

*表示所有可能的值。例如，* 在分字段表示每分钟。

,表示枚举值。例如，1,3,5 在秒字段表示第 1、3、5 秒。

-表示范围。例如，1-5 在秒字段表示第 1 到 5 秒。

/表示增量。例如，0/15 在秒字段表示从第 0 秒开始，每 15 秒一次。

?表示无特定值，用于日和周字段，避免冲突。

L表示最后，用于日和周字段。例如，L 在日字段表示当月的最后一天。

W表示工作日，用于日字段。例如，15W 表示离 15 号最近的工作日。

#表示第几周的第几天，用于周字段。例如，6#3 表示第 3 个周五。

示例：
每分钟执行一次：

0 * * * * *

每小时的第 15 分钟执行一次：

0 15 * * * *

每天的 10:15 执行一次：

0 15 10 * * *

每周一的 10:15 执行一次：

0 15 10 ? * MON

每月的最后一天的 23:59 执行一次：

0 59 23 L * ?

每月的第 1 个工作日的 9:00 执行一次：

0 0 9 1W * ?

举一个实例：使用 @Scheduled 注解配置定时任务：
定义一个方法，添加注解0 15 10 * * ? 表示每天上午 10:15 执行一次定时任务。

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class MyScheduledTask {

    @Scheduled(cron = "0 15 10 * * ?")
    public void doTask() {
        System.out.println("定时任务执行...表示每天上午 10:15 执行一次定时任务。");
    }
}

SpringBoot+MyBatista 框架整合部分（参照最后课堂实验 8+最后大作业） ⭐⭐⭐⭐⭐⭐

答：这部分的分值占百分之60％

主要就是dao-service-controller 三层架构搞清楚了这里问题不大：
还有sql语句要熟练

举一个最简单的代码示例完整结束这一个大问题：

新建一个Entity包下的实体类User，实体类属性名与数据库中的数据表名和字段名对应。

User.java

public class User {
    private Long id;
    private String username;
    private String password;

    // Getter 和 Setter 方法
}

Mapper 层：UserMapper.xml 及其接口

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.example.mapper.UserMapper">
    <insert id="insertUser" parameterType="com.example.entity.User">
        INSERT INTO users (username, password) VALUES (#{username}, #{password})
    </insert>

    <select id="selectUserById" parameterType="long" resultType="com.example.entity.User">
        SELECT * FROM users WHERE id = #{id}
    </select>

    <update id="updateUser" parameterType="com.example.entity.User">
        UPDATE users SET username = #{username}, password = #{password} WHERE id = #{id}
    </update>
</mapper>

UserMapper.java

import org.apache.ibatis.annotations.Mapper;
import com.example.entity.User;

@Mapper
public interface UserMapper {
    void insertUser(User user);
    User selectUserById(Long id);
    void updateUser(User user);
}

Service 层：接口及其接口实现类如何向映射层转发指令

public interface UserService {
    void saveUser(User user);
    User getUserById(Long id);
    void updateUser(User user);
}

UserServiceImpl.java

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.example.entity.User;
import com.example.mapper.UserMapper;

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public void saveUser(User user) {
        userMapper.insertUser(user);
    }

    @Override
    public User getUserById(Long id) {
        return userMapper.selectUserById(id);
    }

    @Override
    public void updateUser(User user) {
        userMapper.updateUser(user);
    }
}

Controller 层
UserController.java

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import com.example.entity.User;
import com.example.service.UserService;

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService;

    @PostMapping
    public String saveUser(@RequestBody User user) {
        userService.saveUser(user);
        return "用于信息保存成功";
    }

    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.getUserById(id);
    }

    @PutMapping
    public String updateUser(@RequestBody User user) {
        userService.updateUser(user);
        return "用于信息更新成功！";
    }
}

模板文件的编辑文件
前端的user.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>User List</title>
</head>
<body>
    <h1>User List</h1>
    <table>
        <thead>
            <tr>
                <th>ID</th>
                <th>Username</th>
                <th>Password</th>
            </tr>
        </thead>
        <tbody>
            <tr th:each="user : ${users}">
                <td th:text="${user.id}"></td>
                <td th:text="${user.username}"></td>
                <td th:text="${user.password}"></td>
            </tr>
        </tbody>
    </table>
</body>
</html>

注意这里的<tr th:each="user : ${users}"> 中的 user 和 ${users}

${users}
含义：${users} 是一个 Thymeleaf 表达式，用于从模型（Model）中获取名为 users 的属性值。

类型：users 通常是一个集合（如 List、Set 等），包含多个对象（如 User 对象）。

示例：假设在控制器中，你将一个 List<User> 对象添加到模型中，并命名为 users。

@GetMapping("/users")
public String getUsers(Model model) {
    List<User> users = userService.getAllUsers();
    model.addAttribute("users", users);
    return "user";
}

th:each 属性
含义：th:each 是 Thymeleaf 的一个迭代属性，用于遍历集合中的每个元素。

语法：th:each="item : $collection"，其中item是迭代变量，${collection} 是要遍历的集合。

作用：遍历集合中的每个元素，并将每个元素绑定到 item 变量上。

3. user
   含义：user 是迭代变量，表示集合中的每个元素。

类型：user 的类型与集合中元素的类型相同（如 User 对象）。

作用：在每次迭代中，user 变量将引用集合中的一个元素，可以在模板中使用该变量来访问元素的属性。

<tbody>
            <!-- 遍历 users 集合，将每个 user 对象绑定到 user 变量 -->
            <tr th:each="user : ${users}">
                <td th:text="${user.id}"></td>
                <td th:text="${user.username}"></td>
                <td th:text="${user.password}"></td>
            </tr>
        </tbody>

最后的最后就是配置文件了application.properties

# 数据源设置
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# 映射文件所在位置
mybatis.mapper-locations=classpath:mapper/*.xml

# 实体类所在的包设置
mybatis.type-aliases-package=com.example.entity

总结

• Entity 层：实体类属性名与数据库字段名对应。

  Mapper 层：XML 映射文件和接口，实现插入、查询、修改等数据库操作。

  Service 层：接口和实现类，向映射层转发指令。

  Controller 层：处理 HTTP 请求，调用服务层方法，返回页面或数据。

  模板文件：Thymeleaf 模板，展示数据。

  配置文件：配置数据源、映射文件位置、实体类包等。

人类学会走路，也得学会摔跤，而且只有经过摔跤他才能学会走路。——马克思