标签 java 下的文章

2024-08-20

AJAX，即Asynchronous JavaScript and XML（异步JavaScript和XML），是一种创建交互式网页应用的技术。它允许浏览器与服务器进行数据交换而无需刷新页面。

以下是使用原生JavaScript进行AJAX请求的示例代码：




// 创建一个新的XMLHttpRequest对象
var xhr = new XMLHttpRequest();
 
// 配置请求类型、URL 以及是否异步处理
xhr.open('GET', 'your-api-endpoint', true);
 
// 设置请求完成的回调函数
xhr.onreadystatechange = function () {
  // 请求完成并且响应状态码为 200
  if (xhr.readyState === XMLHttpRequest.DONE) {
    if (xhr.status === 200) {
      // 处理请求成功的响应数据
      console.log(xhr.responseText);
    } else {
      // 处理请求失败
      console.error('AJAX Request failed');
    }
  }
};
 
// 发送请求
xhr.send();

在这段代码中，我们首先创建了一个新的XMLHttpRequest对象，然后使用open方法设置请求的类型、URL 以及是否异步处理（设为true以进行异步请求）。接着，我们定义了onreadystatechange事件处理函数来监听请求的不同状态变化。最后，我们调用send方法发送请求。

请注意，根据你的实际API端点和需求，你可能需要对请求方法（如GET、POST）、URL、是否发送数据以及响应类型进行相应的调整。

- 阅读更多 -

JavaEE开发之servlet+jsp+tomcat

System

2024-08-20

所有,ajax

以下是一个简单的Java EE开发示例，使用Servlet和JSP结合Tomcat进行Web应用开发。

首先，确保你的开发环境中已经安装了Tomcat服务器和相应的Java Development Kit (JDK)。

创建一个简单的Servlet：




import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
 
public class HelloWorldServlet extends HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
            response.setContentType("text/html");
            PrintWriter out = response.getWriter();
            out.println("<html><body><h1>Hello World</h1></body></html>");
    }
}

编译这个Servlet并将生成的.class文件放入Tomcat的webapps/你的应用名/WEB-INF/classes目录下，与包的结构对应。
创建一个JSP文件：

在webapps/你的应用名/WEB-INF/jsp目录下创建一个hello.jsp文件，内容如下：




<html>
<body>
    <h1>Hello, <%= request.getParameter("name") %></h1>
</body>
</html>

创建一个Servlet来处理请求并转发到JSP页面：




public class GreetingServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
            String name = request.getParameter("name");
            request.setAttribute("name", name);
            RequestDispatcher dispatcher = request.getRequestDispatcher("/WEB-INF/jsp/hello.jsp");
            dispatcher.forward(request, response);
    }
}

在web.xml中配置Servlet：




<web-app>
    <servlet>
        <servlet-name>hello</servlet-name>
        <servlet-class>HelloWorldServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
 
    <servlet>
        <servlet-name>greeting</servlet-name>
        <servlet-class>GreetingServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>greeting</servlet-name>
        <url-pattern>/greeting</url-pattern>
    </servlet-mapping>
</web-app>

启动Tomcat服务器，并通过浏览器访问Servlet，例如：http://localhost:8080/你的应用名/hello 或 http://localhost:8080/你的应用名/greeting?name=World。

这个简单的例子展示了如何使用Servlet和JSP创建一个基本的Web应用。在实际开发中，你可能需要使用框架（如Spring MVC）来简化开发过程，但理解基本的原理仍然是必要的。

System

2024-08-20

所有,ajax

这是一个校园二手物品交易平台的项目，使用了Java、JSP、Servlet、JavaScript、Ajax和MySQL等技术。由于篇幅限制，我将提供一个简化的用户登录功能的代码示例。




// LoginServlet.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.sql.*;
 
public class LoginServlet extends HttpServlet {
    public void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        String username = request.getParameter("username");
        String password = request.getParameter("password");
 
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            String url = "jdbc:mysql://localhost:3306/yourdatabase";
            Connection con = DriverManager.getConnection(url, "username", "password");
            Statement stmt = con.createStatement();
 
            String sql = "SELECT * FROM users WHERE username='" + username + "' AND password='" + password + "'";
            ResultSet rs = stmt.executeQuery(sql);
 
            if (rs.next()) {
                HttpSession session = request.getSession();
                session.setAttribute("user", username);
                response.sendRedirect("welcome.jsp");
            } else {
                response.sendRedirect("login.jsp?error=1");
            }
            con.close();
        } catch (Exception e) {
            e.printStackTrace();
            response.sendRedirect("login.jsp?error=1");
        }
    }
}

在这个简化的例子中，我们定义了一个LoginServlet类，它处理登录请求。它连接到数据库，检查用户名和密码，如果匹配，则创建一个会话并重定向到欢迎页面。如果不匹配或数据库操作出错，它会重定向到登录页面并附上错误参数。

请注意，这个例子没有处理安全性问题，如SQL注入攻击，建议使用预编译的SQL语句或使用参数化查询来避免这些问题。同时，硬编码数据库凭据不是一个好的实践，应该使用属性文件或环境变量来安全地管理凭据。

System

2024-08-20

所有,ajax

JavaWeb项目中，这些技术的用途和组合通常是为了构建一个功能丰富、易于维护的Web应用程序。

Maven：依赖管理和项目构建自动化工具，用于简化项目构建过程，统一项目结构。
MyBatis：是一个优秀的持久层框架，用于简化数据库操作，将SQL语句与Java代码分离。
Spring：为了解决企业应用开发的复杂性而创建的一个分层的JavaSE/EE full-stack(一站式)轻量级开源框架，主要用于IOC(控制反转)和AOP(面向切面编程)。
Spring MVC：是Spring框架的一部分，是一个web应用程序框架，用于构建web应用程序。
AJAX：（Asynchronous JavaScript and XML），用于在不刷新页面的情况下更新网页数据，提高用户体验。

举例：

假设你需要创建一个简单的用户管理系统，你可以使用Spring MVC处理web请求，Spring用于管理bean，MyBatis处理数据库操作，Maven管理项目依赖和构建。用户的创建和查询可以通过AJAX异步发送到后端进行处理。

以下是一个简单的用户管理系统的Maven项目的pom.xml文件的一部分，展示了这些技术的集成：




<dependencies>
    <!-- Spring MVC -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.10</version>
    </dependency>
    <!-- Spring JDBC -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.3.10</version>
    </dependency>
    <!-- MyBatis -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.6</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.9</version>
    </dependency>
    <!-- Database driver, for example MySQL -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.23</version>
    </dependency>
</dependencies>

在这个例子中，我们使用了Spring MVC来处理web请求，Spring用于管理bean的生命周期，MyBatis用于数据库操作的抽象，以及MySQL数据库驱动。这些技术的组合提供了一个强大的开发环境，用于快速开发和维护用户管理系统。

- 阅读更多 -

DWR框架--让前端JS代码调用JAVA后端的方法

System

2024-08-20

所有,ajax

DWR（Direct Web Remoting）是一个用于改善Web应用程序开发的开源JavaScript框架，它允许在客户端JavaScript代码中直接调用服务器端Java方法。

以下是使用DWR框架让前端JavaScript代码调用Java后端方法的基本步骤：

添加DWR依赖到项目中。
配置DWR的servlet。
创建Java类和需要被调用的方法。
使用DWR注解或配置文件来暴露Java方法。
在JavaScript中调用暴露的Java方法。

以下是一个简单的示例：

步骤1: 在pom.xml中添加DWR依赖（如果是Maven项目）：




<dependency>
    <groupId>org.directwebremoting</groupId>
    <artifactId>dwr</artifactId>
    <version>3.0.M1</version>
</dependency>

步骤2: 在web.xml中配置DWR的Servlet：




<servlet>
    <servlet-name>dwr-invoker</servlet-name>
    <servlet-class>org.directwebremoting.servlet.DwrServlet</servlet-class>
    <init-param>
        <param-name>debug</param-name>
        <param-value>true</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>
 
<servlet-mapping>
    <servlet-name>dwr-invoker</servlet-name>
    <url-pattern>/dwr/*</url-pattern>
</servlet-mapping>

步骤3: 创建Java类和方法：




public class MyJavaService {
    public String sayHello(String name) {
        return "Hello, " + name + "!";
    }
}

步骤4: 暴露Java方法。使用DWR注解或者在dwr.xml中配置：




@DwrScriptService
public class MyJavaService {
    // ...
}

或者使用dwr.xml配置：




<dwr>
  <allow>
    <create creator="new" javascript="MyJavaService">
      <param value="com.example.MyJavaService"/>
      <include method="sayHello"/>
    </create>
  </allow>
</dwr>

步骤5: 在JavaScript中调用Java方法：




function callJavaMethod() {
    MyJavaService.sayHello('World', function(data) {
        alert(data); // 将会显示 'Hello, World!'
    });
}

确保在页面中引入了DWR引擎的JavaScript文件，通常是通过<script>标签引入。




<script src='/your-app-context/dwr/interface/MyJavaService.js'></script>
<script src='/your-app-context/dwr/engine.js'></script>
<script src='/your-app-context/dwr/util.js'></script>

然后可以通过调用callJavaMethod函数来触发对Java方法的调用。

System

2024-08-20

所有,javascript

以下是实现这些排序算法的JavaScript代码示例：

冒泡排序：




function bubbleSort(arr) {
    let swapped;
    do {
        swapped = false;
        for (let i = 0; i < arr.length - 1; i++) {
            if (arr[i] > arr[i + 1]) {
                let temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
                swapped = true;
            }
        }
    } while (swapped);
    return arr;
}

选择排序：




function selectionSort(arr) {
    let min;
    for (let i = 0; i < arr.length - 1; i++) {
        min = i;
        for (let j = i + 1; j < arr.length; j++) {
            if (arr[j] < arr[min]) {
                min = j;
            }
        }
        let temp = arr[i];
        arr[i] = arr[min];
        arr[min] = temp;
    }
    return arr;
}

快速排序：




function quickSort(arr) {
    if (arr.length <= 1) {
        return arr;
    }
    let pivot = arr[Math.floor((arr.length - 1) / 2)];
    let left = [], right = [];
    for (let i = 0; i < arr.length; i++) {
        if (arr[i] < pivot) {
            left.push(arr[i]);
        } else if (arr[i] > pivot) {
            right.push(arr[i]);
        }
    }
    return quickSort(left).concat([pivot], quickSort(right));
}

插入排序：




function insertionSort(arr) {
    let key, j;
    for (let i = 1; i < arr.length; i++) {
        key = arr[i];
        j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j = j - 1;
        }
        arr[j + 1] = key;
    }
    return arr;
}

二分插入排序：




function binaryInsertionSort(arr) {
    for (let i = 1; i < arr.length; i++) {
        let key = arr[i], left = 0, right = i - 1;
        while (left <= right) {
            let mid = Math.floor((left + right) / 2);
            if (arr[mid] > key) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        for (let j = i - 1; j >= left; j--) {
            arr[j + 1] = arr[j];
        }
        if (left !== i) {
            arr[left] = key;
        }
    }
    return arr;
}

希尔排序：




function shellSort(arr) {
    let gap = arr.length / 2;
    while (gap > 0) {
        for (let i = gap; i < arr.length; i++) {
            let temp = arr[i];
            let j = i;
            while ((j >= gap) && (arr[j - gap] > temp)) {

System

2024-08-20

所有,javascript




// 引入CryptoJS库
const CryptoJS = require("crypto-js");
 
// AES加密函数
function encryptAES(data, secretKey) {
    return CryptoJS.AES.encrypt(data, secretKey).toString();
}
 
// AES解密函数
function decryptAES(ciphertext, secretKey) {
    const bytes  = CryptoJS.AES.decrypt(ciphertext, secretKey);
    return bytes.toString(CryptoJS.enc.Utf8);
}
 
// 使用示例
const secretKey = 'your-256-bit-secret-key'; // 应该是一个复杂的密钥，不要公开
const message = 'Hello World!';
 
// 加密
const encrypted = encryptAES(message, secretKey);
console.log('Encrypted:', encrypted);
 
// 解密
const decrypted = decryptAES(encrypted, secretKey);
console.log('Decrypted:', decrypted);

在这段代码中，我们首先引入了crypto-js库，然后定义了encryptAES和decryptAES两个函数来分别处理加密和解密。在使用时，你需要替换your-256-bit-secret-key为你自己的密钥，并确保该密钥在解密时可用。这段代码提供了一个简单的示例，展示了如何使用AES算法来加密和解密数据。

System

2024-08-20

所有,javascript




// 引入必要的Three.js组件
import * as THREE from 'three';
 
// 设置场景、相机和渲染器
const scene = new THREE.Scene();
const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
const renderer = new THREE.WebGLRenderer();
renderer.setSize(window.innerWidth, window.innerHeight);
document.body.appendChild(renderer.domElement);
 
// 创建几何体、材质和网格对象
const geometry = new THREE.BoxGeometry(1, 1, 1);
const material = new THREE.MeshBasicMaterial({ color: 0x00ff00 });
const cube = new THREE.Mesh(geometry, material);
 
// 将几何体添加到场景中
scene.add(cube);
 
// 设置相机位置并查看场景
camera.position.z = 5;
 
// 渲染循环
function animate() {
  requestAnimationFrame(animate);
 
  // 旋转立方体
  cube.rotation.x += 0.01;
  cube.rotation.y += 0.01;
 
  // 渲染场景
  renderer.render(scene, camera);
}
 
animate(); // 开始动画循环

这段代码创建了一个简单的3D场景，包含一个绿色的立方体，并且会持续旋转。这是学习Three.js的一个很好的起点，它演示了如何设置场景、相机、渲染器，以及如何添加和动画处理几何体。

- 阅读更多 -

JS（JavaScript）的引用方式介绍与代码演示

System

2024-08-20

所有,javascript

在JavaScript中，有两种主要的引入方式来引用JavaScript文件：

使用HTML的<script>标签直接在HTML文件中引入。
使用JavaScript的import语句从其他JavaScript模块中引入。

下面是两种方式的示例代码：

使用<script>标签引入：




<!-- 直接在HTML文件中引入外部JS文件 -->
<script src="path/to/your/script.js"></script>

使用import语句引入（需要在支持模块化的JavaScript环境中，如现代浏览器或使用诸如Webpack的模块打包器）：




// 在支持ES6模块化的JavaScript文件中使用import引入
import { myFunction } from './module.js';
 
myFunction();

在这两种方式中，src属性用于指定要引入的JavaScript文件的路径，而import语句则用于从模块中引入特定的功能或变量。注意，模块化JavaScript需要相应的环境支持，并可能需要设置特定的构建工具或服务。

System

2024-08-20

所有,javascript

在有向图中，头节点是入度为0的节点，尾节点是出度为0的节点。

以下是针对不同编程语言的解决方案：

Java:




import java.util.*;
 
public class Solution {
    /**
     * 获取头节点和尾节点
     * @param graph 图的邻接表表示
     * @return 头节点和尾节点数组
     */
    public int[] getHeadAndTailNodes(List<List<Integer>> graph) {
        int[] degrees = new int[graph.size()];
        boolean[] isHead = new boolean[graph.size()];
        boolean[] isTail = new boolean[graph.size()];
        
        // 计算每个节点的度
        for (int i = 0; i < graph.size(); i++) {
            for (int neighbor : graph.get(i)) {
                degrees[neighbor]++;
            }
        }
        
        // 标记头节点和尾节点
        for (int i = 0; i < graph.size(); i++) {
            if (degrees[i] == 0) {
                isHead[i] = true;
            }
            if (graph.get(i).isEmpty()) {
                isTail[i] = true;
            }
        }
        
        // 统计头节点和尾节点的数量
        int headCount = 0, tailCount = 0;
        for (int i = 0; i < isHead.length; i++) {
            if (isHead[i]) {
                headCount++;
            }
            if (isTail[i]) {
                tailCount++;
            }
        }
        
        // 不存在头节点或尾节点的情况
        if (headCount == 0 || tailCount == 0) {
            return new int[]{-1, -1};
        }
        
        // 寻找唯一的头节点和尾节点
        int headNode = -1, tailNode = -1;
        for (int i = 0; i < isHead.length; i++) {
            if (isHead[i]) {
                if (headNode == -1) {
                    headNode = i;
                } else {
                    headNode = -1; // 不唯一
                    break;
                }
            }
            if (isTail[i]) {
                if (tailNode == -1) {
                    tailNode = i;
                } else {
                    tailNode = -1; // 不唯一
                    break;
                }
            }
        }
        
        return new int[]{headNode, tailNode};
    }
}

JavaScript:




/**
 * @param {number[][]} graph
 * @return {number[]}
 */
var getHeadAndTailNodes = function(graph) {
    let degrees = new Array(graph.length).fill(0);
    let isHead = new Array(graph.length).fill(false);
    let isTail = new Array(graph.length).fill(false);
    
    // 计算每个节点的度
    for (let i = 0; i < graph.length; i++) {
        for (let neighbor of graph[i]) {
            degrees[neighbor]++;
        }
    }
    
    //

- 阅读更多 -