java基础编程设计



1、使用HttpSession接口，实现自定义的Session类，实现HttpSession接口中的所有方法，并实现自定义的Session管理功能；

2、在web.xml中配置自定义的Session类，使用<session-config>标签，并设置session-class属性；

3、在Servlet中使用HttpServletRequest的getSession()方法，获取自定义的Session对象；

4、在自定义的Session类中，实现Session的存储、更新、删除等功能；

5、在Servlet中，使用HttpServletRequest的getSession()方法，获取自定义的Session对象，并使用Session对象的方法，实现Session的操作；

6、在Servlet中，使用HttpServletRequest的invalidate()方法，销毁自定义的Session对象，以及其中的所有数据。

可以使用Java内置的排序函数Arrays.sort()对二维数组进行排序，需要传入一个Comparator对象来指定按照哪个条件进行排序。比如按照二维数组第一列升序排列可以这样实现：

import java.util.Arrays; import java.util.Comparator; public class Sort2DArray { public static void main(String[] args) { int[][] arr = {{5, 6}, {1, 2}, {3, 4}}; Arrays.sort(arr, Comparator.comparingInt(a -> a[0])); for (int[] row : arr) { System.out.println(Arrays.toString(row)); } } }

输出结果为：

[1, 2] [3, 4] [5, 6]

 
 其中`Comparator.comparingInt(a -> a[0])`表示按照二维数组的第一列进行升序排序，如果要按照其他列或者降序排序，只需要修改这个Comparator即可。   总结了以下一些相关知识点，不管是平时工作或是面试中都是常见的功能模块： 
 
 
  
Servlet：Servlet 是 Java Web 应用程序的基本构建块之一。Servlet 是运行在 Web 服务器上的 Java 类，用于处理来自客户端的请求并生成响应。
 
  
JSP：JSP（JavaServer Pages）是一种动态 Web 页面技术，允许开发人员使用 Java 代码和 HTML 标记创建动态 Web 页面。
 
  
Web 应用程序部署：Web 应用程序通常打包成 WAR（Web 应用程序归档）文件，然后部署到 Web 服务器上。
 
  
MVC 模式：MVC（Model-View-Controller）是一种设计模式，用于开发 Web 应用程序。MVC 模式将应用程序分为三个部分：模型、视图和控制器。
 
  
Web 服务：Web 服务是一种使用标准化协议（如 HTTP）进行通信的应用程序，通常用于在不同系统之间共享数据和功能。
 
  
RESTful Web 服务：REST（Representational State Transfer）是一种 Web 服务架构风格，使用 HTTP 协议的 GET、POST、PUT 和 DELETE 方法来处理资源。RESTful Web 服务是符合 REST 架构风格的 Web 服务。
 
  
SOAP Web 服务：SOAP（Simple Object Access Protocol）是一种 Web 服务协议，用于在网络上传输结构化数据。SOAP Web 服务通常使用 XML 格式进行通信。
 
  
JDBC：JDBC（Java Database Connectivity）是 Java 语言中用于与关系型数据库交互的 API。它提供了一组类和接口，用于执行 SQL 语句、访问数据库元数据和管理数据库连接等操作。
 
  
ORM：ORM（Object-Relational Mapping）是一种编程技术，用于将面向对象的编程语言（如 Java）中的对象映射到关系型数据库中的表。Hibernate 和 MyBatis 等 ORM 框架可用于简化与数据库的交互。
 
  
Spring 框架：Spring 是一种轻量级的开源框架，用于构建企业级应用程序。它提供了许多功能，包括依赖注入、AOP（Aspect-Oriented Programming）、数据访问和 MVC 等功能。
 
  
Servlet 容器：Servlet 容器是 Web 服务器中的一个组件，用于运行和管理 Servlet。Tomcat、Jetty 和 GlassFish 等是常用的 Servlet 容器。
 
  
Web 安全：Web 安全是保护 Web 应用程序免受恶意攻击的一组技术和**实践。包括使用 HTTPS、防止 XSS（Cross-Site Scripting）和 CSRF（Cross-Site Request Forgery）攻击、限制对敏感数据的访问等等。
 
  
Servlet 生命周期：Servlet 的生命周期包括初始化、服务和销毁三个阶段。在初始化阶段，Servlet 容器会创建 Servlet 实例并调用其 init() 方法。在服务阶段，Servlet 实例会处理客户端请求并生成响应。在销毁阶段，Servlet 容器会调用 Servlet 实例的 destroy() 方法来销毁它。
 
  
JSP 生命周期：JSP 的生命周期包括编译、初始化、服务和销毁四个阶段。在编译阶段，JSP 引擎会将 JSP 页面转换为 Servlet。在初始化阶段，Servlet 容器会创建 JSP 页面对应的 Servlet 实例并调用其 init() 方法。在服务阶段，Servlet 实例会处理客户端请求并生成响应。在销毁阶段，Servlet 容器会调用 Servlet 实例的 destroy() 方法来销毁它。
 
  
Filter：Filter 是一种 Java Web 组件，用于在 Servlet 容器处理请求之前或之后对请求和响应进行处理。Filter 可用于实现 Web 安全、日志记录、字符编码转换等功能。
 
  
Listener：Listener 是一种 Java Web 组件，用于监视 Web 应用程序的状态并在状态发生变化时执行特定的操作。ServletContextListener、HttpSessionListener 和 ServletRequestListener 等是常用的 Listener。
 
  
JavaServer Faces（JSF）：JSF 是一种用于构建用户界面的 Java Web 框架。JSF 提供了一组标准组件和生命周期管理机制，可以帮助开发人员构建复杂的用户界面。
 
  
WebSocket：WebSocket 是一种基于 TCP 协议实现的全双工通信协议，可用于实现实时的双向数据传输。Java EE 7 中引入了对 WebSocket 的支持，可以使用 Java API 或 WebSocket 框架实现 WebSocket。
 
  
Spring Boot：Spring Boot 是 Spring 框架的一种变体，用于简化 Spring 应用程序的开发和部署。Spring Boot 提供了自动配置、嵌入式 Web 服务器、健康检查、运行时度量等功能，可以快速构建可独立运行的 Spring 应用程序。
 
  
微服务架构：微服务架构是一种将应用程序拆分为一组小型、自治的服务的架构风格。每个服务都有自己的数据库和业务逻辑，并通过轻量级的通信机制（如 RESTful API 或消息队列）与其他服务进行交互。Java Web 应用程序可以使用 Spring Cloud 和 Netflix OSS 等框架实现微服务架构。
 
 
   在 Java Web 应用程序中，可以通过以下方式共享 Socket 会话： 1.使用 ServletContextListener 监听器： 创建一个实现了 ServletContextListener 接口的类，在其 contextInitialized 方法中创建一个共享的 Socket 对象，并将其存储在 ServletContext 中。在需要使用 Socket 的 Servlet 中，可以通过 ServletContext 获取该 Socket 对象。 例如： 
 
 
  
public class SocketListener implements ServletContextListener { private ServerSocket serverSocket; public void contextInitialized(ServletContextEvent event) { try { serverSocket = new ServerSocket(8080); event.getServletContext().setAttribute("socket", serverSocket); } catch (IOException e) { // handle exception } } public void contextDestroyed(ServletContextEvent event) { try { serverSocket.close(); } catch (IOException e) { // handle exception } } } 
 
 
 在上述示例中，创建了一个 ServerSocket 对象，并将其存储在 ServletContext 中。在需要使用 Socket 的 Servlet 中，可以通过如下方式获取该 Socket 对象： 
 
 
  
ServerSocket serverSocket = (ServerSocket) getServletContext().getAttribute("socket"); 
 
 
 2.使用 HttpSessionListener 监听器： 创建一个实现了 HttpSessionListener 接口的类，在其 sessionCreated 方法中创建一个共享的 Socket 对象，并将其存储在 HttpSession 中。在需要使用 Socket 的 Servlet 中，可以通过 HttpSession 获取该 Socket 对象。 例如： 
 
 
  
public class SocketListener implements HttpSessionListener { private Socket socket; public void sessionCreated(HttpSessionEvent event) { try { socket = new Socket("localhost", 8080); event.getSession().setAttribute("socket", socket); } catch (IOException e) { // handle exception } } public void sessionDestroyed(HttpSessionEvent event) { try { socket.close(); } catch (IOException e) { // handle exception } } }
 
 
 
 在上述示例中，创建了一个 Socket 对象，并将其存储在 HttpSession 中。在需要使用 Socket 的 Servlet 中，可以通过如下方式获取该 Socket 对象： 
 
 
  
Socket socket = (Socket) getSession().getAttribute("socket"); 
 
 
 
 3.使用数据库或缓存存储共享信息： 可以将共享信息存储在数据库或缓存中，并在需要使用时进行查询。例如，可以将 Socket 对象存储在 Redis 缓存中，并在需要使用 Socket 时从 Redis 中查询。 例如： 
 
 
  
public class SocketListener { private Jedis jedis; public void init() { jedis = new Jedis("localhost", 6379); } public void destroy() { jedis.close(); } public Socket getSocket(String key) { String socketJson = jedis.get(key); Socket socket = null; if (socketJson != null) { Gson gson = new Gson(); socket = gson.fromJson(socketJson, Socket.class); } return socket; } public void setSocket(String key, Socket socket) { Gson gson = new Gson(); String socketJson = gson.toJson(socket); jedis.set(key, socketJson); } }
 
 
 
 在上述示例中，使用了 Redis 缓存存储 Socket 对象。在需要使用 Socket 的 Servlet 中，可以通过调用 getSocket 方法获取 Socket 对象。 
 
 
  
SocketListener socketListener = new SocketListener(); socketListener.init(); Socket socket = socketListener.getSocket("socket1"); 
 
 
 4.使用 Java NIO： Java NIO（New I/O）包提供了非阻塞 I/O 操作，可以在同一个线程中同时处理多个 I/O 操作。使用 Java NIO，可以在多个 Servlet 之间共享一个 Socket 通道。 例如： 
 
 
  
public class SocketListener { private Selector selector; public void init() { try { selector = Selector.open(); ServerSocketChannel serverSocketChannel = ServerSocketChannel.open(); serverSocketChannel.socket().bind(new InetSocketAddress(8080)); serverSocketChannel.configureBlocking(false); serverSocketChannel.register(selector, java基础编程设计 SelectionKey.OP_ACCEPT); } catch (IOException e) { // handle exception } } public void destroy() { try { selector.close(); } catch (IOException e) { // handle exception } } public void process() { while (true) { try { selector.select(); Iterator<SelectionKey> keys = selector.selectedKeys().iterator(); while (keys.hasNext()) { SelectionKey key = keys.next(); if (key.isAcceptable()) { // handle accept } else if (key.isReadable()) { // handle read } else if (key.isWritable()) { // handle write } keys.remove(); } } catch (IOException e) { // handle exception } } } }
 
 
 在上述示例中，创建了一个 ServerSocketChannel 对象，并将其注册到 Selector 中。在需要使用 Socket 的 Servlet 中，可以通过调用 SocketListener 的 process 方法，在同一个线程中处理多个 Socket 通道。 
 
 
  
SocketListener socketListener = new SocketListener(); socketListener.init(); socketListener.process(); 
 
 
 5.使用消息队列： 另一种共享 Socket 会话的方法是使用消息队列。在这种情况下，Socket 对象将被写入消息队列，并由多个 Servlet 或其他应用程序共享和使用。 例如，可以使用 Apache ActiveMQ 消息队列来共享 Socket 对象。在需要使用 Socket 的 Servlet 中，可以从消息队列中获取 Socket 对象，并在处理完请求后将其放回消息队列。 例如： 
 
 
  
public class SocketListener implements MessageListener { private ConnectionFactory connectionFactory; private Connection connection; private Session session; private Destination destination; private MessageConsumer messageConsumer; public void init() { try { connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616"); connection = connectionFactory.createConnection(); connection.start(); session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); destination = session.createQueue("socket.queue"); messageConsumer = session.createConsumer(destination); messageConsumer.setMessageListener(this); } catch (JMSException e) { // handle exception } } public void destroy() { try { messageConsumer.close(); session.close(); connection.close(); } catch (JMSException e) { // handle exception } } @Override public void onMessage(Message message) { try { if (message instanceof ObjectMessage) { ObjectMessage objectMessage = (ObjectMessage) message; Socket socket = (Socket) objectMessage.getObject(); // handle socket } } catch (JMSException e) { // handle exception } } public void sendSocket(Socket socket) { try { ObjectMessage objectMessage = session.createObjectMessage(socket); MessageProducer messageProducer = session.createProducer(destination); messageProducer.send(objectMessage); } catch (JMSException e) { // handle exception } } }
 
 
 在上述示例中，使用了 ActiveMQ 消息队列来共享 Socket 对象。在需要使用 Socket 的 Servlet 中，可以通过调用 sendSocket 方法将 Socket 对象写入消息队列。 
 
 
  
SocketListener socketListener = new SocketListener(); socketListener.init(); socketListener.sendSocket(socket); 
 
 
 以上是一些在 Java Web 应用程序中共享 Socket 会话的方法，具体实现方法取决于应用程序的需求和特定场景。要注意的是，共享 Socket 对象可能会导致线程安全问题，因为多个线程可能会同时访问同一个 Socket 对象。要确保对共享 Socket 对象的访问是同步的，并且在使用 Socket 时，需要考虑线程安全性。    Java Web 函数是指在 Java Web 开发中常用的一些函数或方法，以下是一些常见的基础知识：1. HTTP 请求方法：常见的 HTTP 请求方法有 GET、POST、PUT、DELETE 等，用于表示客户端对服务器资源的请求方式。2. Servlet：Java Web 应用程序的核心组件，用于接收和处理 HTTP 请求，并生成响应结果。3. JSP：Java Server Pages 的缩写，用于在服务器端生成 HTML 页面，与 Servlet 一起使用。4. Request 对象：用于封装客户端发出的 HTTP 请求，包含请求方法、URL、请求头、请求体等信息。5. Response 对象：用于封装服务器返回的 HTTP 响应，包含响应头、响应体等信息。6. Session 对象：用于在服务器端保存用户会话信息，如登录状态、购物车信息等。7. Cookie 对象：用于在客户端保存用户会话信息，如用户登录信息等。8. JDBC：Java 数据库连接，用于在 Java Web 应用程序中访问数据库。9. DAO（Data Access Object）：数据访问对象，用于封装数据库操作，提供简单、统一的数据访问接口。10. ORM（Object Relational Mapping）：对象关系映射，用于将数据库中的表映射到 Java 对象上，简化数据库操作。   在Java web编程中，static是一个关键字，用于表示静态的方法、变量和类。它可以与类、方法和变量一起使用。 
 
 
  
静态变量：使用static关键字定义的变量是静态变量。静态变量是类级别的，即它们属于类而不是任何单个实例。这意味着无论创建多少个类的实例，静态变量都只有一个副本，并且可以在任何实例中访问。静态变量可以通过类名来访问，而不需要创建类的实例。例如，ClassName.staticVariable。
 
  
静态方法：使用static关键字定义的方法是静态方法。静态方法不需要实例化类即可调用，并且只能访问静态变量和其他静态方法。在Java web编程中，静态方法通常用于实用程序函数或辅助函数，这些函数可以在应用程序中的任何位置调用。静态方法可以使用类名来调用，例如ClassName.staticMethod()。
 
  
静态类：使用static关键字定义的嵌套类是静态类。静态类与非静态类不同，因为它们不需要外部类的实例即可创建。静态类通常用于将一组相关的功能组合到单个实体中，并且可以通过类名来访问静态类，例如ClassName.StaticNestedClass。
 
 
 在《Java思想编程》书中说： 
 

   “static方法就是没有this的方法。在static方法内部不能调用非静态方法，反过来是可以的。而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途。” 
 
 
下面我们通过一段代码来解释一下它的功能：
 
 
 
  
public class Demo1 { public static void main(String[] args) { Test.p="静态变量赋值了"; Test.say(); new Test(); } } class Test{ Test(){ System.out.println("构造方法执行了"); } static String p ; static{ System.out.println("静态代码块执行了"); } public static void say(){ System.out.println("静态方法执行了"); System.out.println(p); } public void say2(){ System.out.println("方法执行了"); System.out.println(p); } }
 
 
 代码中我们分别使用static定义了静态变量、静态代码块和静态方法，执行结果如下： 
 
 
   
 
 我们可以发现，最先执行的意图据是static修饰的代码块，在我们通过类名直接调用方法say之前就执行乐，然后是我们通过类名访问的静态方法say，最后才是构造方法。为什么我们还没有创建对象就可以访问类中的内容呢？——这就涉及到了关键字static的使用方法。 
static关键字的使用方法
 
1.修饰变量和方法
 被static修饰的变量和方法我们统称为静态变量和静态方法，属于类的静态资源，是类实例之间共享的，简单地说，即不随着创建对象的改变而发生改变。以普通变量和方法为例：我们写一段简单的代码 
 
 
  
public class Demo1 { public static void main(String[] args) { Test t1 = new Test(); Test t2 = new Test(); t1.p = "变量赋值了"; t1.x =1; t2.x =2; t1.say(); } } class Test{ String p; static int x; void say(){ System.out.println("方法执行了"); System.out.println(p); System.out.println(x); }
 
 
 这段代码很简单，即我们通过创建的对象t来访问Test类中的内容，与上一段代码不同的是我们不能通过类名的方式来直接调用这些变量方法，如Test.p和Test.say，而是要通过创建的新对象t。但是我们却可以用对象t来访问静态变量x，但是变量x的内容属于类，对象t1,t2是共享一个变量x的，通过两个对象赋值后，结果取最后赋的值，所以输出的结果如下。 
 
 
   
 
 
 
2.静态代码块
 静态静态块也是static的重要应用之一。通常使用于类的初始化，和静态变量、静态方法一样，静态块里面的代码只执行一次，且只在初始化类的时候执行。
为了更清楚地描述静态代码块的功能，我们编写如下代码。 
 
 
  
public class Demo1 { public static void main(String[] args) { new Test2(); new Test1(); } } class Test2 extends Test1{ static{ System.out.println("静态代码块1执行了"); } static{ System.out.println("静态代码块2执行了"); } } class Test1{ static { System.out.println("静态代码块3执行了"); } } 
 
 
 不难看出，静态代码块随着对象的创建，或者说类的实例化而进行，且只进行一次，我们创建了两个对象，但是每个语句只打印了一次。我们根据他们打印的顺序可以推断出静态代码块的执行规则。
1.按照父类到子类的顺序执行。
2.在同一个类中按照代码的顺序执行
3.每个静态代码块只执行一次
静态代码块可以优化程序性能，正是因为它的特性：只会在类被初次加载的时候执行一次。 
 
 
   
 
 
 
3.静态内部类
 static正常情况下是不能用来修饰类的，它只能修饰内部类，也就是我们说的静态内部类，它的应用场景相对于以上两个功能少得多，通常我们使用内部类时会保存一个引用，引用是指向创建它的外围内，但是静态内部类却没有。没有这个引用就意味着：
1、它的创建是不需要依赖外围类的创建。
2、它不能使用任何外围类的非static成员变量和方法。
我们通过代码示例来简单地介绍一下静态内部类使用方法 
 
 
  
package com.java.demo1; public class Demo1 { public static void main(String[] args) { Test.Test2 t = new Test.Test2(); t.say(); } } class Test { static class Test2 { void say(){ System.out.println("静态内部类"); } } } 
 
 
 
为什么要使用static
 好了，说到这里，可能一些初学者会问，为什么要使用静态呢？首先我们总结一下被静态static修饰的变量/方法/方法块/类的特点 静态修饰的特点
1.被static修饰的变量/方法是独立与类所创建的对象而存在的，简而言之，当我们创建多个对象实例时，static修饰的变量/方法是被它们所共享的，即不随着不同对象的创建而发生改变。
2.static在类加载时就创建好了内存空间，但是它的内容是可以改变的，我们可以通过不同的对象给它赋值，但是它的值取决于你最终给它的赋值。
3.即便不创建对象，static修饰的变量或方法也是可以存在的，当一个类加载完毕后，类中static修饰的变量和方法就可以进行访问。
静态修饰的优点 1.方便在我们没有创建对象时，调用类中的方法/变量
2.static可以用来修饰类的成员方法、成员变量或编写static代码块，能够有效地优化程序性能
我们可以通过下面一段代码来直观地感受一下 
 
 
 
  
package com.java.demo1; public class Demo1 { public static void main(String[] args) { Test t1 = new Test(); Test t2 = new Test(); Test t3 = new Test(); t1.name = "张三"; t2.name = "李四"; t3.name = "王麻子"; t1.age = 18; t2.age = 18; t3.age = 19; Test.school = "清华大学"; t1.say(); t2.say(); t3.say(); } } class Test { String name; int age; static String school; void say(){ System.out.println("我是"+name+",今年"+age+"岁,就读于"+school); } } 
 
 
 运行结果如下 
 
 
 
 
   
 
 
 对于三个对象，他们的school属性是完全相同的，因此为了不占用过多内存，我们用static把变量school修饰成静态变量，如果我们发现变量school的内容写错了，也可以通过一次修改就达成修改所有对象的目的。 
注意事项
 介绍完了static的优点，接下来说一些使用static关键字时经常出现的错误和需要大家注意的一些细节。 
1.static不会改变类中成员的访问权限
 很多初学者容易把java中的static和C/C++中的static搞混了，在C/C++中，static能够改变成员的访问权限，而这在java中时不行的，在java中只能通过四个权限修饰符来改变成员的访问权限 
 
 
   
 
 
 如图所示，我们直接给private封装的变量school赋值时，会提示错误。 
2.静态方法不能引用非静态资源
 这一点是初学者经常犯的错误，当我们定义了一个非静态的变量/方法后，如果我们通过静态的变量或方法来访问非静态的资源时程序是会报错的。这其实不难理解，我们之前说过，静态修饰的变量/方法在类初始化时加载，它们的创建顺序是在非静态资源之前的，我们用已经创建的资源去访问没有被创建的资源，这显然是不合理的。但反过来，非静态资源/静态资源则是可以访问静态资源的。我们通过代码来直观地感受一下。 
 
 
   
 
 
 
3.可以通过this来访问静态的资源
 虽然我们之前提到过，静态的资源本身是独立于实例化的对象而存在的，但是我们却可以通过对象来访问静态的资源，所有的静态方法和静态变量都可以通过对象访问（只要访问权限足够）。我们再通过一个案例来感受： 
 
 
  
public class Demo1 { public static void main(String[] args) { Test t = new Test(); t.say(); } } class Test { static int num = 1; void say(){ int num = 2; System.out.println(this.num); } } 
 
 
 结果输出为1，代码中的this.num并没有指向方法say中定义的num，这里的this还是指向了Test类，显然我们是可以通过对象本身来访问静态资源的。   在 Java web 中使用 JDBC 框架需要经过以下步骤： 
 
 
  
导入 JDBC 驱动程序：在项目中导入 JDBC 驱动程序，以便能够连接数据库。可以将 JDBC 驱动程序的 jar 包添加到项目的 classpath 中，或者通过 Maven 或 Gradle 等构建工具来管理依赖。
 
  
加载 JDBC 驱动程序：在代码中加载 JDBC 驱动程序，可以使用 Class.forName() 方法来加载驱动程序，也可以使用 DriverManager.registerDriver() 方法来注册驱动程序。
 
  
建立数据库连接：使用 DriverManager.getConnection() 方法建立与数据库的连接，需要指定数据库的 URL、用户名和密码等参数。
 
  
创建 Statement 或 PreparedStatement 对象：使用 Connection 对象创建 Statement 或 PreparedStatement 对象，用于执行 SQL 语句。
 
  
执行 SQL 语句：使用 Statement 或 PreparedStatement 对象执行 SQL 语句，可以使用 execute()、executeQuery()、executeUpdate() 等方法。
 
  
处理结果集：如果 SQL 语句返回了结果集，可以使用 ResultSet 对象来处理结果集，例如遍历结果集、获取结果集中的数据等。
 
  
关闭连接和资源：在使用完数据库连接、Statement 或 PreparedStatement 对象以及 ResultSet 对象后，需要将它们关闭，以释放资源。
 
 
 示例代码如下： 
 
 
  
// 加载 JDBC 驱动程序 Class.forName("com.mysql.cj.jdbc.Driver"); // 建立数据库连接 String url = "jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai"; String username = "root"; String password = ""; Connection conn = DriverManager.getConnection(url, username, password); // 创建 PreparedStatement 对象 String sql = "SELECT * FROM user WHERE username=?"; PreparedStatement pstmt = conn.prepareStatement(sql); // 设置参数 pstmt.setString(1, "admin"); // 执行查询，获取结果集 ResultSet rs = pstmt.executeQuery(); // 处理结果集 while (rs.next()) { int id = rs.getInt("id"); String username = rs.getString("username"); String password = rs.getString("password"); System.out.println("id=" + id + ", username=" + username + ", password=" + password); } // 关闭连接和资源 rs.close(); pstmt.close(); conn.close();
 
 
 以上是 JDBC 框架的基本使用方法，实际开发中还需要注意安全性、性能等问题。同时，为了简化开发，也可以使用 ORM 框架来替代 JDBC 框架，例如 MyBatis、Hibernate 等。   Java Web 项目中，可以使用 Arrays 类的 toString() 方法将数组转换为字符串，示例如下： 
 int[] arr = {1, 2, 3, 4, 5}; String str = Arrays.toString(arr); System.out.println(str); // 输出：[1, 2, 3, 4, 5] 
 
 如果需要将字符串数组转换为逗号分隔的字符串，可以使用 StringUtils 类的 join() 方法，示例如下： 
 
 String[] arr = {"Hello", "world", "!"}; String str = StringUtils.join(arr, ","); System.out.println(str); // 输出：Hello,world,! 
 
 需要注意的是，StringUtils 类的 join() 方法需要通过 Maven 导入 Apache Commons Lang3 库，即添加以下依赖： 
 
 <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-lang3</artifactId> <version>3.12.0</version> </dependency>    
0.题外话
 题外话，下次问题背景描述可以更详细一点，例如： 
 

   我正在使用xx框架 做一个XX系统，我在做登录模块的时候，遇到了xx问题，我是期望达成xx效果，请问应该怎么做？ 
 
 这个问题，只有一个用户登录，它的歧义在与，你的系统只能允许一个用户登录，还是一个用户在某个设备（手机、浏览器等）登录了之后就被记住登录态了，不用再输入用户名和密码进行登录了。我这里猜应该是后者。 
1.为什么需要用户登录？
 如果做的只是一个匿名论坛，可以不用登录，因为你不需要知道用户的身份。 但是，如果是要做一个类似知乎一样的问答，你就需要知道用户身份（虽然也有匿名提问和回答），确保只有经过身份验证的用户才能访问其特定功能和编辑其数据。电商网站也是类似。 所以：一是为了标识身份；二是为了保护数据安全；三可以做一些个性化推荐等。 
2.登录态的实现原理是什么？
 所谓的登录态（类似记住我），就是在同一个设备登录之后，不需要重新再输入用户名和密码了。 其原理如下： 1）用户第一次输入用户名和密码，验证通过之后，server端下发一个凭证，并关联凭证和用户信息 
 

   类似你在物业认证你是小区业主之后，发给你一个门禁卡（凭证） 
 
 2）client端保存这个凭证到本地，进行持久化（可以是浏览器本地cookie，可以是app的数据存储等） 3）下次用户再通过该设备访问（client端在请求的时候，会把凭证带给server端），server端判断该凭证是否有效，如果有效，则放行（无需登录 
 

   类似你拿到门禁卡刷门禁，无需再人工确认你的业务身份了 
 
 在软件开发里面，一般把这个凭证叫做 token. 如果你公司很大，是一个集团，有多个网站提供给用户（例如：腾讯），希望整个集团下面同一个用户身份（登录）就可以在多个网站共用，那么就需要一个登录服务，我们把这个叫做单点登录服务。同样，公司内部很多OA办公系统，你也不期望每个都让你输入用户名和密码登录一下。 
 

   单点登录（Single Sign-On，简称SSO）是一种身份验证和授权机制，它允许用户只需一次登录，就可以在多个应用程序中访问受保护的资源。具体而言，用户只需在第一次登录时提供身份验证信息，然后该信息将被保存在一个中央身份验证服务器中。接下来，用户无需再次输入身份验证信息，即可在该身份验证服务器允许的所有应用程序中访问资源。 
  
单点登录服务主要解决了以下两个问题： 
  
 
  1）减少用户的认证次数和登录时间：在传统的多系统环境中，用户需要为每个应用程序输入不同的用户名和密码进行身份验证，这既繁琐又费时。单点登录服务可以减少用户的认证次数和登录时间，提高用户的使用体验。 
  
 
  2）提高安全性：单点登录服务可以降低用户输入密码的次数，从而降低密码被窃取或猜测的风险。此外，中央身份验证服务器可以集中处理身份验证请求，实现更加严格的身份验证和授权机制，提高系统的安全性。 
 
 
3.使用JAVA具体实现登录的代码
 具体的JAVA实现代码，就不贴了，善于去使用搜索引擎和github去帮助你寻找对应的内容，以下是我搜到的两个： https://www.bezkoder.com/spring-boot-login-example-mysql/ https://github.com/a/smart-sso 
4.额外需要注意的事项
 保持登录态固然方便，但是同时也需要注意一些安全问题( 生产环境运行的系统，除了功能性，还有非功能性的需求），以下是常见的几个： 
 

   token什么时候过期？ 
  
token需要绑定设备信息，避免被盗取后在其它设备使用 
  
修改密码之后，需要使token失效 
  
是否允许多个设备同时登录？ 
  
登录接口是否有必要接入智能验证码？避免被程序攻击 
  
用户的唯一ID生成，以及用户的其它主键（例如：手机号） 
  
用户量有多大，是否需要提前进行分库分表设计？ 
 
    
 
 
   
   
 
 见字如面，我是咕泡科技创始人Mic（谭锋） 策略模式是一种设计模式，它定义了一系列算法，将每个算法封装起来并使它们可以相互替换。在Java Web中，我们可以使用策略模式来处理一些业务逻辑，如根据不同的用户类型返回不同的数据格式等。 下面是策略模式的实现步骤： 
 
 
  
定义一个策略接口，该接口定义了一个算法方法。
 
 
 
 
 
  
public interface Strategy { public void doOperation(); }
 
 
 2. 实现策略接口的具体算法类，每个类实现算法方法并根据实际需求进行业务逻辑处理。 
 
 
  
public class StrategyA implements Strategy { @Override public void doOperation() { // 算法A的具体实现逻辑  } } ​ public class StrategyB implements Strategy { @Override public void doOperation() { // 算法B的具体实现逻辑  } }
 
 
 3. 定义一个上下文类，该类持有一个策略对象，并提供一个方法用于切换策略。 
 
 
  
public class Context { private Strategy strategy; ​ public Context(Strategy strategy) { this.strategy = strategy; } ​ public void setStrategy(Strategy strategy) { this.strategy = strategy; } ​ public void executeStrategy() { strategy.doOperation(); } }
 
 
 4. 在具体业务逻辑中使用上下文对象调用算法方法。 
 
 
  
public class MyController { private Context context; ​ public MyController(Strategy strategy) { this.context = new Context(strategy); } ​ public void execute() { context.executeStrategy(); } }
 
 
 在上面的示例中，我们定义了一个策略接口Strategy，其中包含一个算法方法doOperation()。然后，我们实现了两个具体的策略类StrategyA和StrategyB，分别实现了算法方法，并根据实际需求进行业务逻辑处理。接着，我们定义了一个上下文类Context，该类持有一个策略对象，并提供一个方法用于切换策略。最后，在具体业务逻辑中使用上下文对象调用算法方法。 
 
 
   
   
 
    MediaRecorder 是一个用于录制音频和视频的 Web API，它主要应用于浏览器环境。请注意，MediaRecorder 不是 Java Web 的一部分，而是 JavaScript 的一部分。以下是一个简单示例，展示如何在浏览器中使用 JavaScript 初始化 MediaRecorder。 首先，创建一个 HTML 文件，如 index.html：
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>MediaRecorder Example</title> </head> <body> <button id="startRecording">开始录制</button> <button id="stopRecording">停止录制</button> <script src=https://www.zhihu.com/topic//"main.js"></script> </body> </html> 接下来，创建一个 JavaScript 文件，如 main.js： const startRecordingButton = document.getElementById("startRecording"); const stopRecordingButton = document.getElementById("stopRecording"); 
 let mediaRecorder; let recordedChunks = []; 
 async function initMediaRecorder() { try { const stream = await navigator.mediaDevices.getUserMedia({ audio: true, video: true }); mediaRecorder = new MediaRecorder(stream); 
 mediaRecorder.addEventListener("dataavailable", (event) => { if (event.data.size > 0) { recordedChunks.push(event.data); } }); 
 mediaRecorder.addEventListener("stop", () => { const blob = new Blob(recordedChunks, { type: "video/webm" }); const url = URL.createObjectURL(blob); // 可以用这个 URL 在浏览器中播放录制的视频，或者将其上传到服务器 console.log("录制完成，视频 URL: ", url); }); 
 startRecordingButton.addEventListener("click", () => { recordedChunks = []; mediaRecorder.start(); console.log("开始录制..."); }); 
 stopRecordingButton.addEventListener("click", () => { mediaRecorder.stop(); console.log("停止录制..."); }); } catch (error) { console.error("初始化 MediaRecorder 失败:", error); } } 
 initMediaRecorder(); 在这个示例中，我们首先获取了音频和视频的媒体流，然后创建了一个 MediaRecorder 实例。我们还添加了 dataavailable 和 stop 事件监听器，分别用于处理媒体数据和停止录制时的操作。最后，我们为 "开始录制" 和 "停止录制" 按钮添加了点击事件处理函数。 保存这两个文件后，在支持 MediaRecorder 的浏览器中打开 index.html 文件，即可开始和停止录制音频和视频。请注意，某些浏览器可能要求在安全上下文（如 HTTPS 或本地主机）中使用 MediaRecorder。   可以使用Java内置的加密库javax.crypto以及Java的安全库java.security。下面是一个示例： 首先，确保在项目中导入了以下库： 
 
 
  
import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.PrivateKey; import java.security.PublicKey; import java.security.NoSuchAlgorithmException; import javax.crypto.Cipher; import java.util.Base64; 
 
 
 创建一个RSA工具类： 
 
 
  
public class RSAUtil { public static final String RSA = "RSA"; public static KeyPair generateKeyPair(int keySize) throws NoSuchAlgorithmException { KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(RSA); keyPairGenerator.initialize(keySize); return keyPairGenerator.genKeyPair(); } public static String encrypt(String plainText, PublicKey publicKey) throws Exception { Cipher encryptCipher = Cipher.getInstance(RSA); encryptCipher.init(Cipher.ENCRYPT_MODE, publicKey); byte[] cipherText = encryptCipher.doFinal(plainText.getBytes("UTF-8")); return Base64.getEncoder().encodeToString(cipherText); } public static String decrypt(String cipherText, PrivateKey privateKey) throws Exception { byte[] bytes = Base64.getDecoder().decode(cipherText); Cipher decryptCipher = Cipher.getInstance(RSA); decryptCipher.init(Cipher.DECRYPT_MODE, privateKey); return new String(decryptCipher.doFinal(bytes), "UTF-8"); } } 
 
 
 接下来，可以在Java Web项目中使用这个RSA工具类进行加密和解密操作： 
 
 
  
public class Main { public static void main(String[] args) { try { // 生成密钥对  KeyPair keyPair = RSAUtil.generateKeyPair(2048); PublicKey publicKey = keyPair.getPublic(); PrivateKey privateKey = keyPair.getPrivate(); // 加密  String plainText = "Hello, RSA!"; String cipherText = RSAUtil.encrypt(plainText, publicKey); System.out.println("加密后的文本: " + cipherText); // 解密  String decryptedText = RSAUtil.decrypt(cipherText, privateKey); System.out.println("解密后的文本: " + decryptedText); } catch (Exception e) { e.printStackTrace(); } } } 
 
 
 在实际的Java Web项目中，可能需要将加密解密的功能与您的Web服务和数据存储结合起来。例如，可以使用公钥加密用户提交的敏感数据，然后将加密后的数据存储在数据库中。当需要访问这些数据时，可以使用私钥解密。请注意，为了保证系统安全，需要妥善保管私钥，以防止泄露或滥用。    
 
 
   
   
 
 见字如面，我是咕泡科技创始人Mic（谭锋） 在 Java Web 应用程序中，可以使用 javax.media.MediaLocator 和 javax.media.MediaRecorder 类来初始化 MediaRecorder。 以下是一个简单的示例代码： 
 
 
  
import javax.media.MediaLocator; import javax.media.MediaRecorder; public class MediaRecorderInitializer { public static MediaRecorder initialize(String outputPath) { try { MediaLocator locator = new MediaLocator("vfw://0"); MediaRecorder recorder = new MediaRecorder(locator); recorder.setDestination(new MediaLocator("file://" + outputPath)); return recorder; } catch (Exception e) { e.printStackTrace(); return null; } } } 
 
 
 上述代码中，使用 MediaLocator 类创建一个定位器（locator），该定位器指定要使用的音视频设备。可以使用 vfw://0 指定 Windows 平台上的默认视频捕捉设备，也可以使用其他 URL 指定其他设备。然后使用 MediaRecorder 类创建一个 MediaRecorder 实例，并将定位器传递给构造函数。接着，使用 MediaRecorder.setDestination() 方法设置要保存录制的音视频的输出路径。最后，返回 MediaRecorder 实例以供后续使用。 需要注意的是，在使用 MediaRecorder 之前，需要确保已经正确安装了相应的音视频设备驱动程序，并且已经正确配置了音视频设备。如果使用的是 Windows 平台上的默认视频捕捉设备，需要先确保已经正确安装了 DirectShow 驱动程序。此外，还需要在应用程序的运行环境中配置相应的依赖项和权限。 
 
 
 
   
   
 
    在Java web项目中，异常处理可以通过以下方式来实现： 
 1. 使用try-catch语句捕获异常，并在catch块中处理异常。例如： 
 

try {

// some code that may throw an exception

} catch (Exception e) {

// handle the exception

}

 
 2. 在方法声明中使用throws关键字声明方法可能抛出的异常，由调用方法处理异常。例如： 
 

public void someMethod() throws Exception {

// some code that may throw an exception

}

 
 3. 使用Servlet的异常处理机制，可以通过实现javax.servlet.Servlet接口的方法来处理异常。例如： 
 

public void service(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

try {

// some code that may throw an exception

} catch (Exception e) {

// handle the exception

}

}

 
 4. 使用框架提供的异常处理机制，如Spring框架的异常处理机制。例如： 
 

@ControllerAdvice

public class GlobalExceptionHandler {

@ExceptionHandler(Exception.class)

public ModelAndView handleException(Exception ex) {

ModelAndView modelAndView = new ModelAndView();

modelAndView.addObject("message", ex.getMessage());

modelAndView.setViewName("error");

return modelAndView;

}

}

 
 以上是Java web项目中常用的异常处理方式，具体的处理方式需要根据项目的实际情况来选择。   在Java Web中，可以使用Session来实现只允许一个用户登陆的功能。具体做法如下： 
 
 
  
当用户登陆成功后，在服务器端创建一个Session对象，并将用户信息保存在Session中。
 
  
在每次请求时，判断当前请求是否包含有效的Session信息。如果存在有效的Session信息，则表示用户已经登陆；否则，表示用户尚未登陆或已过期，需要重新登陆。
 
  
当用户退出登陆时，销毁Session对象。
 
 
 示例代码如下： protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { String username = request.getParameter("username"); String password = request.getParameter("password"); 
 // 验证用户名和密码是否正确 boolean isValidUser = validateUser(username, password); 
 if (isValidUser) { HttpSession session = request.getSession(); // 判断当前是否已有其他用户登陆 if (session.getAttribute("user") != null) { // 其他用户已登陆，提示用户不能重复登陆 response.getWriter().write("Another user has already logged in."); return; } 
 // 将当前用户信息保存在Session中 session.setAttribute("user", username); response.sendRedirect("/home.jsp"); } else { response.getWriter().write("Invalid username or password."); } } 
 protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { HttpSession session = request.getSession(false); if (session != null && session.getAttribute("user") != null) { // 用户已登陆 response.sendRedirect("/home.jsp"); } else { // 用户未登陆或Session已过期 response.sendRedirect("/login.jsp"); } } 
 protected void doLogout(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { HttpSession session = request.getSession(false); if (session != null && session.getAttribute("user") != null) { // 销毁Session对象 session.invalidate(); } response.sendRedirect("/login.jsp"); } 在上述示例中，我们首先在验证用户名和密码正确后，判断当前是否已有其他用户登陆。如果存在其他用户已登陆，则提示用户不能重复登陆；否则，将当前用户信息保存在Session中，并跳转到主页。在每次请求时，通过getSession(false)方法获取当前的Session对象，如果Session已经过期或不存在有效的Session信息，则表示用户未登陆，需要重新登陆。在用户退出登陆时，通过调用invalidate()方法销毁Session对象。   
 
 
  
response.setHeader("Access-Control-Allow-Origin", "*");
 
 
 我觉得最好还是用apache 或者nginx反向代理   在Java Web项目中实现动态代理有多种方式，其中最常见的是使用Java的反射机制和动态代理库来实现。以下是一种基本的实现方法： 1、创建接口：首先，你需要定义一个接口，该接口将成为代理类和被代理类之间的契约。接口应该包含代理类需要实现的方法。 
 
 
  
public interface UserService { void saveUser(User user); User getUser(String username); }
 
 
 2、创建被代理类：实现上述接口的具体类将成为被代理类。在这个例子中，我们创建一个名为UserServiceImpl的类。 
 
 
  
public class UserServiceImpl implements UserService { public void saveUser(User user) { // 实现保存用户的逻辑  } public User getUser(String username) { // 实现获取用户的逻辑  return null; } }
 
 
 3、创建代理类：代理类将实现与被代理类相同的接口，并在其内部引用被代理类的实例。代理类将重写接口中的方法，并在方法中添加额外的功能，例如日志记录、性能监控等。 
 
 
  
import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; public class UserServiceProxy implements InvocationHandler { private Object target; public UserServiceProxy(Object target) { this.target = target; } public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // 添加额外的功能（例如日志记录）  System.out.println("Before method invocation"); // 调用被代理类的方法  Object result = method.invoke(target, args); // 添加额外的功能（例如性能监控）  System.out.println("After method invocation"); return result; } public static Object createProxy(Object target) { return Proxy.newProxyInstance( target.getClass().getClassLoader(), target.getClass().getInterfaces(), new UserServiceProxy(target) ); } }
 
 
 4、在Web项目中使用代理：在你的Java Web项目中，使用代理类来代替直接调用被代理类。首先，创建被代理类的实例，然后使用代理类创建代理对象。最后，通过代理对象调用方法。 
 
 
  
UserServiceImpl userService = new UserServiceImpl(); UserService proxy = (UserService) UserServiceProxy.createProxy(userService); proxy.saveUser(user); // 通过代理对象调用方法 User user = proxy.getUser(username); // 通过代理对象调用方法
 
 
 通过上述步骤，你可以在Java Web项目中实现动态代理。代理类将在调用被代理类的方法之前和之后执行额外的功能。这对于实现横切关注点（例如日志记录、事务管理等）非常有用。请注意，上述示例是基于Java的标准动态代理机制，可以通过反射和代理库来实现。 黑马程序员2023新版JavaWeb开发教程，实现javaweb企业开发全流程（涵盖Spring+MyBatis+SpringMVC+SpringBoot等）_哔哩哔哩_bilibili      

版权声明：

本文来源网络，所有图片文章版权属于原作者，如有侵权，联系删除。

本文网址：https://www.bianchenghao6.com/h6javajc/18314.html