417寝室复习资料

lazy、chen

已于 2023-12-06 16:15:54 修改

阅读量827

点赞数 21

文章标签： java 开发语言

于 2023-12-06 16:12:44 首次发布

本文链接：https://blog.csdn.net/qq_33783517/article/details/134833951

版权

第一章

1、企业级软件项目开发的体系结构？答：企业级软件项目开发的体系结构有两个方向，一种是 C/S 体系结构，一种是 B/S 体系结构。

C/S 体系结构由客户端（Client）和服务器(Servlet)两部分构成。客户端负责人机界面的交互及控制方面的操作，服务器端主要负责数据的交互和保存。
B/S 体系结构由浏览器（Browser）和服务器（Server）组成，服务端又分为应用服务器和数据库服务器，构成了逻辑上的三层结构，有效的使程序和数据分离，提高了每层的独立性。

企业级软件开发规模有什么特点？
1. 基于网络的应用；
2. 巨量的数据集成；
3. 高度的安全；
4. 具备可扩展性。

完整的Java EE分为哪几部分？分别是什么？共分为 4 部分：

组件技术
服务技术
通信技术
架构技术

第二章

1、JSP的特点？答：（1）一次编写，随处运行。

可重用组件技术。
标计化页面开发。
对大型复杂 web 应用支持良好。

例2-4、例2-5、例2-6、例2-8、（例2-9、例2-10）、（例2-11、例2-12）、（例2-13、例2-14）、（例2-15、例2-16）、（例2-19、例2-20）、例2-21、例2-23、例2-24、例2-27
JSP指令标签有哪些？各自的作用是什么？答：有 page、include、taglib 三个指令标签。

page 指令：它是最常用的 JSP 指令，用于定义 JSP 页面的属性，如内容类型、缓存需求、错误页面、导入类等。
include 指令：它用于在 JSP 页面编译时包含另一个文件的内容。这个标签会将被包含的文件内容直接复制到包含指令的位置。
taglib 指令：用于指定 JSP 页面中将使用的标签库的 URI、标签库文件的位置以及在该页面上使用的标签前缀。

JSP有几个常用内置对象？作用分别是什么？

在 JSP 中，有 4 个常用的内置对象，这些对象无需显式声明即可在 JSP 页面中使用，它们的作用如下：

1. request 对象：request 对象封装了来自客户端的请求信息。通过它，可以获取客户端的请求参数、请求头信息、请求体内容等，以便进行相应的响应处理。它是

HttpServletRequest 类的实例。

1. response 对象：response 对象包含了响应客户请求的信息，它用于生成返回给客户端的响应。通过这个对象可以设置响应状态码、响应头、响应体等。response 对象是

HttpServletResponse 类的实例。

1. session 对象：session 对象用于存储在一次会话期间的用户信息。它能够跟踪用户的状态，将用户在页面间的访问信息关联起来。通常用于存储用户登录状态、购物车数据等。
2. application 对象：application 对象代表了当前 web 应用程序的运行环境，可以用来共享数据。比如，可以在 application 对象中保存全局变量，供整个应用程序的不同页面访问。
简述session和application内置对象的区别？

session 和 application 是 JSP 中的两个内置对象，它们之间的主要区别在于作用范围和生命周期：

1. 作用范围：
  - session 对象：它代表了客户端与服务器的一次会话。它的作用范围局限于单个用户的一次会话，从用户打开浏览器访问网站开始，到用户关闭浏览器结束。在会话期间， session 对象可以存储用户相关信息，如用户名、购物车等。
  - application 对象：它代表了整个 web 应用程序的运行环境。它的作用范围是整个应用程序，所有用户共享同一个 application 对象。它通常用于存储全局变量，如系统配置、公共资源等。
2. 生命周期：
  - session对象：随着用户会话的结束而消失，当用户关闭浏览器时，会话结束，session 对象将被销毁。因此，session 对象的生命周期是临时的。
  - application 对象：随着 web 应用程序的启动而创建，在服务器关闭时销毁。因此， application 对象的生命周期是持久的。
JSP常用内置对象的作用范围有什么不同。

徐：JSP 常用内置对象 request、response、session 和 application 的作用范围如下：

1. request 对象：request 对象表示客户端向服务器发送的请求，它的作用范围是当前请求。
2. response 对象：response 对象表示服务器向客户端发送的响应，它的作用范围也是当前请求。
3. session 对象：session 对象表示客户端与服务器之间的一次会话，它的作用范围是当前会话。
4. application 对象：application 对象表示整个 Web 应用程序，它的作用范围是整个应用程序。

第三章

例3-1、例3-2、（例3-4、例3-5）
JavaBean的特征有哪些？答：

内省：使组件可以发表其支持的操作和属性的机制，也是支持在其他组件中发现这种机制的机制。
属性：在设计 bean 时可以改变的外观和行为特征，开发工具通过对 bean 进行内省来获知其属性，进而发布其属性。。
定制：bean 通过发布其属性使其可以在设计时被定制。有两种方法支持定制。通过使用 beans 的属性编辑器或者是使用更复杂的 bean 定制器。
通信：bean 之间通过事件互相通信，开发工具可以检测一个 bean 接收和引发的事件。
持续：使 bean 可以存储和恢复其状态。一个 bean 的属性被修改以后，可以通过对象的持续化机制保存下来。并可以在需要时恢复。

第四章

（例4-2、例4-3）、（例4-8、例4-9）、（例4-12、例4-13）
什么是servlet?

答：Servlet 就是用 JAVA 语言编写出来的程序。它运行在服务端，主要任务是负责基于请求。响应模式的服务端功能。从应用的角度来看，它就是负责响应客户通过页面向服务器发起的

各种请求。做出对应的控制动作，有必要的话，会把处理的结果发送到客户端。

简述 servlet 工作原理？

Servlet 是一种运行在服务器端的 Java 程序，它可以处理客户端发送的 HTTP 请求，并生成相应的 HTTP 响应。Servlet 的工作原理如下：

1. 客户端（通常是浏览器）向服务器发送 HTTP 请求。
2. 服务器接收到请求后，将请求传递给 Servlet 容器（例如 Tomcat）。
3. Servlet 容器根据请求的 URL 找到对应的 Servlet 实例，并创建一个新的线程来处理请求。
4. Servlet 实例在新线程中执行，它可以从请求中获取参数、读取请求头和请求体等信息。
5. Servlet 实例根据请求的内容执行相应的业务逻辑，并生成响应。
6. Servlet 实例将响应返回给 Servlet 容器。
7. Servlet 容器将响应传递给服务器，服务器再将响应发送给客户端。

需要注意的是，Servlet 是一种无状态的程序，它不会在内存中保存任何状态信息。因此，每次请求都会创建一个新的 Servlet 实例来处理请求，这使得 Servlet 具有很好的可伸缩性和安全性。

第五章

1、JSP如何连接mysql数据库？

导入必要的依赖库：在 JSP 文件中，使用<%@page

import="java.sql.DriverManager,java.sql.Connection,java.sql.PreparedStatement,java.sql.Res ultSet"%>语句导入 MySQL 驱动程序和数据库操作相关的类。

<%=Class.forName("com.mysql.jdbc.Driver")%>语句注册 MySQL 驱动程序。

创建数据库连接：使用 DriverManager.getConnection()方法创建与 MySQL 数据库的连接，传入数据库的 URL、用户名和密码等参数。

2、JSP连接数据库后对数据库表中的记录进行增、删、改、查？编程实现其中之一

<%@page

import="java.sql.DriverManager,java.sql.Connection,java.sql.PreparedStatement,java.sql.Res ultSet"%>

// 注册 MySQL 驱动程序

Class.forName("com.mysql.jdbc.Driver");

// 创建数据库连接

String url = "jdbc:mysql://localhost:3306/db_name";

String username = "username";

String password = "password";

Connection conn = DriverManager.getConnection(url, username, password);

// 创建 PreparedStatement 对象

String sql = "SELECT * FROM table_name";

PreparedStatement pstmt = conn.prepareStatement(sql);

// 执行查询并获取结果

ResultSet rs = pstmt.executeQuery();

// 处理结果

while (rs.next()) {

String id = rs.getString("id");

String name = rs.getString("name");

String age = rs.getString("age");

out.println("ID: " + id + ", Name: " + name + ", Age: " + age);

}

// 关闭资源

rs.close(); pstmt.close(); conn.close();

---------------------------------------------------------------------

第六章

1、简述MVC模式？答：MVC（Model-View-Controller）模式是一种软件架构模式，用于将软件系统分为三个主要部分：模型（Model）、视图（View）和控制器（Controller）。

模型：负责处理数据和业务逻辑，它代表了系统的核心功能。
视图：负责呈现模型中的数据，它是用户与系统交互的界面。
控制器：负责处理用户输入和控制模型与视图之间的交互，它协调模型和视图的工作。 MVC 模式的核心思想是将系统的不同部分分离，使得它们可以独立地开发、测试和维护。这种分离有助于提高系统的可维护性、可扩展性和可复用性。

在 MVC 模式中，模型、视图和控制器之间的交互通常通过事件驱动的方式进行。当用户与视图交互时，控制器会接收用户输入并将其传递给模型进行处理。模型会处理请求并更新其数据状态，然后通知控制器。控制器再将更新后的数据传递给视图，视图会根据模型的数据更新用户界面。

MVC模式的开发有哪些优势？答：1、具有多个视图对应一个模型的能力。
1. 由于一个应用被分离为三层，因此有时改变其中的一层就能满足应用的改变。一个应用的业务流程或者业务规则的改变只需改动 mvc 模型层即可。
2. 控制层的管理能力更加有效。
3. VC 模式有利于软件工程化管理。由于不同的层各司其职，每一层的不同应用具有某些相同的特征。有利于通过工程化，工具化生产管理程序代码。
采用MVC模式开发计算三角形的面积。
1. 定义模型类 Triangle，它包含三个属性 a, b, c 表示三角形的三边。

Triangle. java public class Triangle { private double a; private double b; private double c;

// 构造函数、getter 和 setter 省略

}

1. 创建 JSP 页面，用于输入三角形的三边。

Input.jsp

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

<!DOCTYPE html>

<html>

<head>

<title>计算三角形面积</title>

</head>

<body>

<h1>计算三角形面积</h1>

<form action="CalculateTriangleArea" method="post"> 三角形边长 a: <input type="text" name="a"><br> 三角形边长 b: <input type="text" name="b"><br> 三角形边长 c: <input type="text" name="c"><br> <input type="submit" value="计算面积">

</form>

</body>

</html>

3. 在 servlet 中，实现海伦公式计算面积。

CalculateTriangleArea .java

@WebServlet("/CalculateTriangleArea") public class CalculateTriangleArea extends HttpServlet { protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { double a = Double.parseDouble(request.getParameter("a")); double b = Double.parseDouble(request.getParameter("b")); double c = Double.parseDouble(request.getParameter("c")); Triangle triangle = new Triangle(); triangle.setA(a); triangle.setB(b); triangle.setC(c); double p = (a + b + c) / 2; double area = Math.sqrt(p * (p - a) * (p - b) * (p - c)); triangle.setArea(area);

request.setAttribute("triangle", triangle);

RequestDispatcher dispatcher = request.getRequestDispatcher("result.jsp"); dispatcher.forward(request, response);

}

4. 创建结果 JSP 页面，用于显示计算出的面积。 result.jsp

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

<!DOCTYPE html>

<html>

<head>

<title>计算三角形面积</title>

</head>

<body>

<h1>三角形面积计算结果</h1> 三角形的三边分别为：${triangle.a}，${triangle.b}，${triangle.c}，面积为：

${triangle.area}

</body>

</html>

4、在mysql中建立数据库studentDB,在数据库中建表info,表中字段为：学号、姓名、性别、年龄、分数，采用JSP实现，MVC+JDBC+mysql模式实现对表中记录的查询或增加。该示例包括对数据库中表记录的查询和增加功能。

创建数据库和表
- 创建名为 `studentDB` 的数据库。
- 在 `studentDB` 数据库中创建名为 `info` 的表，表结构如下： - 学号（`id`）：主键，整数类型。
- 姓名（`name`）：字符串类型。
- 性别（`gender`）：字符串类型，可为 "男" 或 "女"。
- 年龄（`age`）：整数类型。
- 分数（`score`）：整数类型。

创建模型类
- 创建一个名为 `Student` 的模型类，用于封装学生信息。

public class Student { private int id; private String name; private String gender; private int age; private int score;

// 构造函数，初始化学生信息

public Student(int id, String name, String gender, int age, int score) { this.id = id; this.name = name; this.gender = gender; this.age = age; this.score = score;

}

// 获取和设置学生信息的方法 public int getId() { return id;

}

public void setId(int id) { this.id = id;

}

public String getName() { return name;

}

public void setName(String name) { this.name = name;

}

public String getGender() { return gender;

}

public void setGender(String gender) { this.gender = gender;

}

public int getAge() { return age;

}

public void setAge(int age) { this.age = age;

}

public int getScore() { return score;

}

public void setScore(int score) { this.score = score;

}

3. 创建控制器类

- 创建一个名为 `StudentController` 的控制器类，用于处理学生信息的查询和增加操作。

```java public class StudentController {

private static final String JDBC_DRIVER = "com.mysql.jdbc.Driver"; private static final String JDBC_URL = "jdbc:mysql://localhost:3306/studentDB"; private static final String USERNAME = "your_username"; private static final String PASSWORD = "your_password";

// 查询学生信息的方法

public void queryStudentInfo() { try {

// 创建数据库连接

Connection conn = DriverManager.getConnection(JDBC_URL, USERNAME,

PASSWORD);

// 创建 SQL 查询语句

String query = "SELECT * FROM info";

// 创建 Statement 对象

Statement stmt = conn.createStatement();

// 执行查询语句并获取结果集

ResultSet rs = stmt.executeQuery(query);

// 创建学生信息列表

List<Student> students = new ArrayList<>();

// 遍历结果集，将学生信息添加到列表中

while (rs.next()) {

Student student = new Student( rs.getInt("id"), rs.getString("name"), rs.getString("gender"), rs.getInt("age"), rs.getInt("score")

); students.add(student);

}

// 将学生信息列表传递给视图

request.setAttribute("students", students);

// 转发到查询结果页面

RequestDispatcher dispatcher =

request.getRequestDispatcher("/queryStudent.jsp"); dispatcher.forward(request, response);

// 关闭数据库连接

conn.close(); } catch (SQLException e) { e.printStackTrace();

}

// 增加学生信息的方法

public void addStudentInfo() { try {

// 获取表单提交的数据

int id = Integer.parseInt(request.getParameter("id")); String name = request.getParameter("name"); String gender = request.getParameter("gender"); int age = Integer.parseInt(request.getParameter("age")); int score = Integer.parseInt(request.getParameter("score"));

// 创建学生对象

Student student = new Student(id, name, gender, age, score);

// 创建数据库连接

Connection conn = DriverManager.getConnection(JDBC_URL, USERNAME,

PASSWORD);

// 创建 SQL 插入语句

String insertQuery = "INSERT INTO info (id, name, gender, age, score) VALUES (?, ?, ?, ?, ?)";

// 创建 PreparedStatement 对象

PreparedStatement stmt = conn.prepareStatement(insertQuery);

// 设置参数

stmt.setInt(1, student.getId()); stmt.setString(2, student.getName()); stmt.setString(3, student.getGender()); stmt.setInt(4, student.getAge()); stmt.setInt(5, student.getScore());

// 执行插入操作

stmt.executeUpdate();

// 关闭数据库连接

conn.close();

// 重定向到查询结果页面

response.sendRedirect("/queryStudent.jsp"); } catch (SQLException e) { e.printStackTrace();

}

4. 创建视图类

- 创建一个名为 `StudentQuery.jsp` 的 JSP 页面，用于展示学生信息的查询结果。 <!DOCTYPE html>

<html>

<head>

<title>学生信息查询</title>

</head>

<body>

<h1>学生信息查询结果</h1>

List<Student> students = (List<Student>) request.getAttribute("students");

<tr>

</tr>

<% for (Student student : students) { %>

<tr>

</tr>

<% } %>

</table>

<a href="addStudent.jsp">添加学生信息</a>

</body>

</html>

```

- 创建一个名为 `StudentAdd.jsp` 的 JSP 页面，用于展示学生信息的添加页面。

<!DOCTYPE html>

<html>

<head>

<title>添加学生信息</title>

</head>

<body>

<h1>添加学生信息</h1>

</form>

</body>

</html>

------------------------------------------------------------------------------

第七章

1、Hibernate项目开发的一般步骤？答：

新建 JAVA 工程；
导入 MySQL 数据库的 JDBC 驱动程序（3）导入 Hibernate 库。。

新建 POJO(JAVA 实体类)文件。
创建 POJO 对应的数据库及表。
Hibernate 配置文件 hibernate.cfg.xml。
新建 Hibernate 映射向导(其实就是选择数据库和数据表) 文件 hibernate.hbm.xml。
编写主类 main()函数, 通过 Hibernate 配置文件和映射文件来对 POJO 类进行持久化处理。将对应该类的操作永久化的存入到 MySQL 数据库中。。

2、在mysql数据库中创建数据库student和表student,表的字段有学号、姓名、性别，创建hibernate项目，实现对表student记录的增加。

答：

（1） Student.java

package cfec;

public class Student { private String id; private String name; private String sex; private Integer age; public String getId() { return id;

} public void setId(String id) { this.id = id;

} public String getName() { return name;

} public void setName(String name) { this.name = name;

} public String getSex() { return sex;

} public void setSex(String sex) { this.sex = sex;

} public int getAge() { return age;

} public void setAge(int age) { this.age = age;

}

（2） Student.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>

<hibernate-mapping>

</class>

</hibernate-mapping> （3） Hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>

<hibernate-configuration>

<session-factory>

<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>

<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_test</prop erty>

</session-factory>

</hibernate-configuration>

（4） AddTest

package cfec; import org.hibernate.*; import org.hibernate.cfg.*; import java.util.*;

public class AddTest {

public static void main(String[] args) {

//创建 configuration 对象并加载 hibernate.cfg.xml 文件

Configuration config=new Configuration().configure();

//获取 sessionFactory

SessionFactory sessionFactory=config.buildSessionFactory();

//得到一个 session

Session session=sessionFactory.openSession();

//开启事务

Transaction transaction=session.beginTransaction();

//执行持久化操作

Student student=new Student(); student.setId("2003001"); student.setName("张三"); student.setSex("男"); student.setAge(19);

//将对象保存到 session 中

session.save(student);

//提交事务

transaction.commit();

//关闭资源

session.close(); sessionFactory.close();

}

---------------------------------------------------------------------------、

第八章

1、Struts2的实现过程？答：

JSP 触发 Action.
Struts2 拦截请求。
Action 返回结果，由不同的 JSP 显示数据。 2、创建一个struts2项目，在页面输出"Hello World !" 答：

（1）HelloWorldAction.java package action;

import com.opensymphony.xwork2.Action; import com.opensymphony.xwork2.ActionSupport;

public class HelloWorldAction extends ActionSupport{

/**

private static final long serialVersionUID = 1L;

public String execute() {

return SUCCESS;

}

（2）struts.xml

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration

2.5//EN" "http://struts.apache.org/dtds/struts-2.5.dtd">

<result name="success">/hello.jsp</result>

</action>

</package>

</struts> （3）web.xml

<?xml version="1.0" encoding="UTF-8"?>

<web-app>

<filter-name>struts2</filter-name>

<filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filterclass>

</filter>

<filter-mapping>

<filter-name>struts2</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

</web-app>

（4） hello.jsp

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

<!DOCTYPE html>

<h1>Hello World!</h1>

</body>

</html>

------------------------------------------------------------------------------

第九章

画出spring框架结构图?

Spring的IoC、Di是指什么？ Spring 中的 IoC 和 Di 是两个重要的概念。

IoC，是 Inversion of Control 的缩写，意思是控制反转。在 Spring 框架中，IoC 是一种设计原则，它通过将创建对象的控制权转移给 Spring 框架进行管理，以降低代码之间的耦合度。 Di，是 Dependency Injection 的缩写，意思是依赖注入。当一个对象 A 依赖于另一个对象 B 时，对象 A 中包含对象 B 的属性以及其的 set 方法或包含对象 B 的有参构造方法，在容器创建对象 B 时，将属性的值通过依赖注入的方式赋予，实现依赖注入。

这两个概念是 Spring 框架的重要组成部分，它们帮助开发者构建松耦合、可扩展的应用程序。

创建一个spring项目，输出"HelloWorld !"。

1、创建 HelloWorld.java package bean;

public class HelloWorld { private String message;

public String getMessage() { return message;

}

public void setMessage(String message) { this.message = message;

}

public void printMessage() {

System.out.println("Message:"+message);

}

创建 applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>

</bean>

</beans>

创建 Main.java package controler; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import bean.HelloWorld; public class Main {

public static void main(String[] args) {

//加载 spring 上下文

ApplicationContext context=new

ClassPathXmlApplicationContext("applicationContext.xml");

//获取 bean

HelloWorld helloWorld=(HelloWorld)context.getBean("helloWorld");

//使用 bean

helloWorld.printMessage();

}