首页 > 编程语言 >【热门】用 Java 构建高并发电子商务网站（深入研究+详解代码）

【热门】用 Java 构建高并发电子商务网站（深入研究+详解代码）

时间：2024-07-16 13:01:41浏览次数：17  
标签：Java 数据库 并发 详解 static statement import config 连接池

书接上回，想必大家都对该类型的话题很感兴趣。是的，这个话题确实很热门，它也有很多优点。
好的，接下来我们进行深入研究。

本作品由老程个人著作，仅供参考

以下是一个简单的 Java Web 应用示例，结合优化建议进行了逐步的优化和讲解：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import redis.clients.jedis.Jedis;

public class ECommerceApp {

   // 数据库连接池
   private static final String DB_URL = "jdbc:mysql://localhost:3306/ecommerce";
   private static final String USER = "root";
   private static final String PASS = "root";

   // Redis 连接
   private static final String REDIS_HOST = "localhost";
   private static final int REDIS_PORT = 6379;

   public static void main(String[] args) {
       // 初始化数据库连接池
       //...

       // 处理用户请求
       handleUserRequest();
   }

   public static void handleUserRequest() {
       // 从缓存中获取数据
       Jedis jedis = new Jedis(REDIS_HOST, REDIS_PORT);
       String cachedData = jedis.get("key");
       if (cachedData!= null) {
           // 直接使用缓存数据
           System.out.println("Using cached data: " + cachedData);
           return;
       }

       // 从数据库中查询数据
       try (Connection connection = getConnectionFromPool();
            PreparedStatement statement = connection.prepareStatement("SELECT * FROM products WHERE category =?");) {

           statement.setString(1, "electronics");

           try (ResultSet resultSet = statement.executeQuery()) {
               while (resultSet.next()) {
                   // 处理查询结果
               }
           }
       } catch (SQLException e) {
           e.printStackTrace();
       }
   }

   // 获取数据库连接池中的连接
   public static Connection getConnectionFromPool() throws SQLException {
       // 实际的数据库连接池实现
       return DriverManager.getConnection(DB_URL, USER, PASS);
   }
}

以下是对上述代码的优化讲解：

1. 数据库优化：

  • 合理设计数据库索引：在实际的数据库表中，针对经常用于查询、连接和排序的列创建合适的索引，以提高查询效率。

  • 读写分离：可以配置主从数据库，将读操作导向从库，减轻主库的压力。

  • 数据库连接池：使用如 HikariCP 或 Druid 等成熟的数据库连接池库来管理数据库连接，避免频繁创建和销毁连接的开销。

2. 缓存优化：

  • 这里使用 Redis 来缓存数据。对于热点数据，如经常访问的商品信息、用户配置等，可以提前存储在 Redis 中，并设置合适的过期时间，以平衡数据的新鲜度和缓存命中率。

3. 负载均衡：

  • 在实际的生产环境中，前端可以使用 Nginx 等负载均衡器将请求分发到多个应用服务器实例上，避免单个实例承受过大的压力。

4. 异步处理与消息队列：

  • 对于耗时的非关键操作，如发送邮件、更新日志等，可以将其放入消息队列（如 RabbitMQ 或 Kafka ）中异步处理，以释放主线程资源，提高系统的并发处理能力。

5. 线程池与并发控制：

  • 引入线程池，如 ThreadPoolExecutor ，来管理线程的创建和销毁，避免过多线程导致的系统开销。

  • 对于共享资源的访问，根据具体情况使用合适的并发控制机制，如 synchronized 关键字、 ReentrantLock 等，确保数据的一致性。

6. 分布式锁：

  • 在分布式环境下，如果多个节点可能同时操作同一资源，可以使用 Redis 分布式锁或 Zookeeper 分布式锁来保证关键操作的原子性和互斥性。

7. 限流与降级：

  • 可以使用 Guava 中的 RateLimiter 或其他限流库来实施限流策略，限制每秒的请求数量。

  • 制定降级预案，例如在高并发时关闭一些非核心功能或返回简化的响应，以保证核心功能的可用性。

8. 性能监控与调优：

  • 集成 Prometheus 和 Grafana 等监控工具，实时监测系统的性能指标，如 CPU 使用率、内存占用、请求响应时间等。根据监控数据进行性能分析，找出性能瓶颈，如数据库查询慢、线程阻塞等，并进行针对性的优化。

9. 代码优化：

  • 优化算法和数据结构：例如，在处理数据时，选择合适的数据结构（如 HashMap 、 ArrayList 等）来提高操作效率，避免不必要的计算和内存占用。

  • 避免在循环中进行复杂的数据库查询或网络请求：将这类操作提取到循环之外，或者进行批量处理，以减少资源消耗。

10. 分布式事务处理：

  • 如果涉及多个服务之间的数据一致性问题，可以采用合适的分布式事务解决方案，如 Seata 框架来保证事务的一致性。

11. 弹性扩容与缩容：

  • 结合 Kubernetes 等容器编排工具，根据系统的负载自动调整服务实例的数量，实现弹性扩容与缩容，以提高资源利用率和系统的可用性。

12. 动静分离：

  • 将静态资源（如图片、CSS、JavaScript 文件）存储在独立的服务器或 CDN 上，与动态内容的处理分离，提高资源的加载速度和系统的性能。

请注意，这只是一个简单的示例和讲解，实际的电子商务网站的优化是一个复杂而持续的过程，需要根据具体的业务需求、系统架构和性能要求进行深入的分析和实施。
那么问题来了，如何提高操作效率呢，接下来我们将不断完善代码。

首先，对于数据库连接部分，可以使用像 HikariCP 这样的连接池库。以下是一个示例代码：

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;

public class DBConnectionPool {

   private static HikariDataSource dataSource;

   static {
       HikariConfig config = new HikariConfig();
       config.setJdbcUrl("jdbc:mysql://localhost:3306/ecommerce");
       config.setUsername("root");
       config.setPassword("root");
       // 其他连接池配置参数
       config.setMaximumPoolSize(20); 
       config.setMinimumIdle(5); 
       config.setConnectionTimeout(30000); 
       config.setIdleTimeout(600000); 
       config.setMaxLifetime(1800000); 
       dataSource = new HikariDataSource(config);
   }

   public static Connection getConnection() throws SQLException {
       return dataSource.getConnection();
   }
}

在处理 Redis 缓存时，可以使用 Redis 的批量操作来提高效率。例如，如果需要获取多个键的值，可以使用 mget 方法。

Jedis jedis = new Jedis(REDIS_HOST, REDIS_PORT);
List<String> keys = Arrays.asList("key1", "key2", "key3");
List<String> values = jedis.mget(keys.toArray(new String[0]));

对于数据库查询，可以考虑使用分页来处理大量数据，避免一次性获取过多数据导致内存溢出。

PreparedStatement statement = connection.prepareStatement("SELECT * FROM products WHERE category =? LIMIT?,?");
statement.setString(1, "electronics");
int page = 1; // 当前页码
int pageSize = 10; // 每页条数
statement.setInt(2, (page - 1) * pageSize);
statement.setInt(3, pageSize);


在处理结果集时，可以使用  ResultSetMetaData  来获取列信息，动态处理不同的列。


ResultSetMetaData metaData = resultSet.getMetaData();
int columnCount = metaData.getColumnCount();
for (int i = 1; i <= columnCount; i++) {
   String columnName = metaData.getColumnName(i);
   // 根据列名进行相应处理
}


在异步处理方面，可以使用线程池结合  CompletableFuture  来实现更高效的异步任务执行。


ExecutorService executor = Executors.newFixedThreadPool(10);

CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
   // 异步任务逻辑
}, executor);


对于分布式锁，可以使用 Redis 的  SETNX  命令结合超时机制来实现简单的分布式锁。


Jedis jedis = new Jedis(REDIS_HOST, REDIS_PORT);
String lockKey = "lock:resource";
long lockTimeout = 10000; // 锁超时时间（毫秒）
if (jedis.setnx(lockKey, "locked") == 1) {
   jedis.expire(lockKey, lockTimeout / 1000);
   // 执行关键操作
   jedis.del(lockKey);
} else {
   // 处理获取锁失败的情况
}

在性能监控方面，可以使用 Micrometer 库结合 Prometheus 来收集更丰富的指标，如数据库连接池的活跃连接数、等待连接数等。

import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.binder.jdbc.HikariCPMetrics;

MeterRegistry registry = // 初始化 MeterRegistry
HikariCPMetrics.monitor(registry, dataSource);

这些优化和深入的代码实现能够在不同方面提高系统的操作效率和性能，但实际应用中需要根据具体的业务需求和系统架构进行选择和调整。

好了，又如何提高数据库操作效率呢？

  1. 合理设计数据库结构：

  • 规范化数据表，避免数据冗余。

  • 选择合适的数据类型，以节省存储空间和提高处理速度。

  1. 建立合适的索引：

  • 针对经常用于查询、连接、排序和分组操作的列创建索引。

  • 但要注意不要过度创建索引，因为过多的索引会影响插入、更新和删除操作的性能。

  1. 优化查询语句：

  • 避免在查询中使用 SELECT * ，而是明确指定需要的列。

  • 合理使用 JOIN 操作，尽量减少不必要的连接。

  • 避免在 WHERE 子句中使用函数对列进行操作，这可能导致索引无法使用。

  1. 缓存常用数据：
  • 利用数据库自身的缓存机制或使用外部缓存（如 Redis）来存储经常访问但不常变化的数据。
  1. 分表和分区：
  • 当数据量过大时，将数据表进行水平或垂直分表，或者按照一定规则进行分区。
  1. 批量操作：
  • 对于大量的插入、更新或删除操作，采用批量处理的方式，减少与数据库的交互次数。
  1. 优化存储引擎：
  • 根据业务需求选择合适的数据库存储引擎，如 InnoDB 或 MyISAM 等。
  1. 监控和分析性能：
  • 使用数据库提供的性能监控工具，查看执行计划、索引使用情况、锁等待等信息，找出性能瓶颈并进行优化。
  1. 读写分离：
  • 配置主从数据库架构，将读操作分配到从库，减轻主库的负担。
  1. 数据库参数调优：
  • 调整数据库的一些配置参数，如缓存大小、连接数等，以适应系统的负载。

这些方法需要根据具体的数据库系统和业务场景进行综合考虑和应用，以达到提高数据库操作效率的目的。

问题来了，如何使用 HikariCP 连接池库？（老程详细解答）

以下是使用 HikariCP 连接池库的基本步骤：

  1. 引入依赖
    首先，在您的项目的构建配置文件（如 Maven 的 pom.xml 或 Gradle 的 build.gradle ）中添加 HikariCP 的依赖：

对于 Maven：

<dependencies>
   <dependency>
       <groupId>com.zaxxer</groupId>
       <artifactId>HikariCP</artifactId>
       <version>4.0.3</version>
   </dependency>
</dependencies>

对于 Gradle：

implementation 'com.zaxxer:HikariCP:4.0.3'
  1. 创建配置对象
    创建一个 HikariConfig 对象来设置连接池的配置参数，例如：
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;

HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://localhost:3306/your_database");
config.setUsername("your_username");
config.setPassword("your_password");
config.setMaximumPoolSize(10); // 设置最大连接数
config.setMinimumIdle(5); // 设置最小空闲连接数
config.setConnectionTimeout(30000); // 连接超时时间（毫秒）
config.setIdleTimeout(600000); // 空闲连接超时时间（毫秒）
config.setMaxLifetime(1800000); // 连接的最大存活时间（毫秒）

您可以根据实际需求调整这些参数的值。

  1. 创建数据源
    使用配置对象创建 HikariDataSource 对象：
HikariDataSource dataSource = new 
HikariDataSource(config);
  1. 获取数据库连接
    通过数据源获取数据库连接：
try (Connection connection = dataSource.getConnection()) {
   // 在此处使用连接进行数据库操作
} catch (SQLException e) {
   e.printStackTrace();
}

这就是使用 HikariCP 连接池库的基本步骤。在实际应用中，您可以根据具体的需求进一步优化配置参数，并在合适的地方管理和使用数据库连接。

接下来，叫你们如何使用在 Java 中HikariCP 连接池。

以下是在 Java 中使用 HikariCP 连接池的完整示例代码：

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class HikariCPExample {

   public static void main(String[] args) {
       // 创建 HikariCP 配置对象
       HikariConfig config = new HikariConfig();
       config.setJdbcUrl("jdbc:mysql://localhost:3306/your_database");
       config.setUsername("your_username");
       config.setPassword("your_password");
       config.setMaximumPoolSize(10); 
       config.setMinimumIdle(5); 
       config.setConnectionTimeout(30000); 
       config.setIdleTimeout(600000); 
       config.setMaxLifetime(1800000); 

       // 创建 HikariCP 数据源
       HikariDataSource dataSource = new HikariDataSource(config);

       // 执行数据库操作
       try (Connection connection = dataSource.getConnection();
            PreparedStatement statement = connection.prepareStatement("SELECT * FROM your_table")) {

           try (ResultSet resultSet = statement.executeQuery()) {
               while (resultSet.next()) {
                   // 处理查询结果
                   System.out.println(resultSet.getString("column_name"));
               }
           }
       } catch (SQLException e) {
           e.printStackTrace();
       }
   }
}

在上述代码中：

  1. 首先设置了 HikariCP 的配置参数，包括数据库 URL、用户名、密码、最大连接数等。

  2. 创建了 HikariDataSource 对象。

  3. 通过数据源获取连接，并执行数据库查询操作。

好了，重磅的压轴来了，接下来是老程花一天时间打造最优化的电子商务网站，大家可以借鉴一下，并且不断完善。

以下是进一步完善后的构建高并发电子商务网站，并充分运用 HikariCP 连接池以实现最优性能和最大规模的示例代码：

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class HighConcurrencyECommerce {

   // 定义 HikariCP 连接池配置
   private static HikariDataSource dataSource;

   static {
       HikariConfig config = new HikariConfig();
       // 数据库连接信息
       config.setJdbcUrl("jdbc:mysql://your_database_host:3306/your_ecommerce_database");
       config.setUsername("your_username");
       config.setPassword("your_password");

       // 连接池大小配置
       config.setMaximumPoolSize(200);  // 根据预期并发量设置最大连接数
       config.setMinimumIdle(50);  // 保持一定数量的空闲连接

       // 连接超时和空闲超时配置
       config.setConnectionTimeout(5000);  // 连接超时时间（毫秒）
       config.setIdleTimeout(300000);  // 空闲连接超时时间（毫秒）

       // 连接存活时间配置
       config.setMaxLifetime(1800000);  // 连接的最大存活时间（毫秒）

       // 其他优化配置
       config.addDataSourceProperty("cachePrepStmts", "true");  // 缓存预处理语句
       config.addDataSourceProperty("prepStmtCacheSize", "500");  // 预处理语句缓存大小
       config.addDataSourceProperty("prepStmtCacheSqlLimit", "4096");  // 缓存的预处理语句的 SQL 长度限制
       config.addDataSourceProperty("useServerPrepStmts", "true");  // 使用服务器端预处理语句
       config.addDataSourceProperty("useLocalSessionState", "true");  // 使用本地会话状态
       config.addDataSourceProperty("rewriteBatchedStatements", "true");  // 重写批量语句

       dataSource = new HikariDataSource(config);
   }

   // 处理用户请求的方法
   public static void handleUserRequest() {
       try (Connection connection = dataSource.getConnection()) {
           // 假设这里是处理商品查询的逻辑
           PreparedStatement statement = connection.prepareStatement("SELECT * FROM products WHERE category =?");
           statement.setString(1, "electronics");

           try (ResultSet resultSet = statement.executeQuery()) {
               while (resultSet.next()) {
                   // 详细处理查询结果，例如构建商品对象并进行后续业务逻辑处理
                   int productId = resultSet.getInt("product_id");
                   String productName = resultSet.getString("product_name");
                   // 更多字段处理...
               }
           }
       } catch (SQLException e) {
           e.printStackTrace();
       }
   }

   // 处理订单创建的方法
   public static void createOrder() {
       try (Connection connection = dataSource.getConnection()) {
           PreparedStatement statement = connection.prepareStatement("INSERT INTO orders (user_id, product_id, quantity) VALUES (?,?,?)");
           statement.setInt(1, 123);  // 示例用户 ID
           statement.setInt(2, 456);  // 示例产品 ID
           statement.setInt(3, 2);  // 示例购买数量

           int rowsAffected = statement.executeUpdate();
           if (rowsAffected > 0) {
               // 订单创建成功的后续处理
           } else {
               // 订单创建失败的处理
           }
       } catch (SQLException e) {
           e.printStackTrace();
       }
   }

   // 处理库存更新的方法
   public static void updateStock() {
       try (Connection connection = dataSource.getConnection()) {
           PreparedStatement statement = connection.prepareStatement("UPDATE stocks SET quantity = quantity -? WHERE product_id =?");
           statement.setInt(1, 1);  // 示例减少的库存数量
           statement.setInt(2, 789);  // 示例产品 ID

           int rowsAffected = statement.executeUpdate();
           if (rowsAffected > 0) {
               // 库存更新成功的后续处理
           } else {
               // 库存更新失败的处理
           }
       } catch (SQLException e) {
           e.printStackTrace();
       }
   }

   // 处理用户登录的方法
   public static boolean userLogin(String username, String password) {
       try (Connection connection = dataSource.getConnection()) {
           PreparedStatement statement = connection.prepareStatement("SELECT * FROM users WHERE username =? AND password =?");
           statement.setString(1, username);
           statement.setString(2, password);

           try (ResultSet resultSet = statement.executeQuery()) {
               return resultSet.next();
           }
       } catch (SQLException e) {
           e.printStackTrace();
           return false;
       }
   }

   // 处理购物车操作的方法
   public static void handleShoppingCart(int userId, int productId, int quantity) {
       try (Connection connection = dataSource.getConnection()) {
           // 检查购物车中是否已存在该商品
           PreparedStatement checkStatement = connection.prepareStatement("SELECT * FROM shopping_cart WHERE user_id =? AND product_id =?");
           checkStatement.setInt(1, userId);
           checkStatement.setInt(2, productId);

           try (ResultSet resultSet = checkStatement.executeQuery()) {
               if (resultSet.next()) {
                   // 如果存在，更新数量
                   PreparedStatement updateStatement = connection.prepareStatement("UPDATE shopping_cart SET quantity =? WHERE user_id =? AND product_id =?");
                   updateStatement.setInt(1, quantity);
                   updateStatement.setInt(2, userId);
                   updateStatement.setInt(3, productId);
                   updateStatement.executeUpdate();
               } else {
                   // 如果不存在，插入新记录
                   PreparedStatement insertStatement = connection.prepareStatement("INSERT INTO shopping_cart (user_id, product_id, quantity) VALUES (?,?,?)");
                   insertStatement.setInt(1, userId);
                   insertStatement.setInt(2, productId);
                   insertStatement.setInt(3, quantity);
                   insertStatement.executeUpdate();
               }
           }
       } catch (SQLException e) {
           e.printStackTrace();
       }
   }

   // 主函数，模拟高并发场景下的请求处理
   public static void main(String[] args) {
       // 模拟多个并发请求
       for (int i = 0; i < 1000; i++) {
           new Thread(() -> {
               handleUserRequest();
               createOrder();
               updateStock();
               if (Math.random() > 0.5) {
                   userLogin("random_username", "random_password");
               }
               handleShoppingCart((int) (Math.random() * 100), (int) (Math.random() * 1000), (int) (Math.random() * 10));
           }).start();
       }
   }
}

上述代码在之前的基础上，增加了用户登录和购物车操作的方法，并在主函数中模拟了更复杂的并发请求场景。

然而，要构建一个完备的高并发电子商务网站，还需要考虑更多方面的优化和完善：

  1. 数据库架构优化：

  • 对数据表进行垂直和水平拆分，将经常一起查询的字段放在同一张表中，减少关联操作。

  • 合理设计索引，避免过度索引导致的性能下降。

  1. 缓存策略：

  • 除了数据库连接池的缓存，使用 Redis 缓存热门商品、用户信息、页面片段等数据。

  • 引入缓存失效策略，根据数据的更新频率和重要性设置不同的缓存过期时间。

  1. 负载均衡：

  • 使用 Nginx 或其他负载均衡器进行请求的分发，实现服务器的横向扩展。

  • 配置健康检查机制，自动剔除故障的服务器节点。

  1. 异步处理与消息队列：

  • 对于耗时的操作，如订单处理、库存更新等，将其放入消息队列（如 RabbitMQ、Kafka）中异步处理，提高响应速度。

  • 确保消息的可靠传递和处理，避免消息丢失或重复处理。

  1. 线程池与并发控制：

  • 优化线程池的配置，根据系统资源和任务类型设置合适的线程数量。

  • 对于共享资源的访问，使用合适的并发工具（如 ReentrantLock、ReadWriteLock 等）进行同步控制。

  1. 分布式锁：
  • 在分布式环境下，使用 Redis 分布式锁或 Zookeeper 分布式锁来保证关键操作的唯一性和原子性。
  1. 限流与降级：

  • 引入限流机制，如令牌桶算法或漏桶算法，限制每秒的请求数量，防止系统过载。

  • 制定降级策略，在高并发或系统故障时，关闭非核心功能或提供简化的服务，保证核心业务的可用性。

  1. 性能监控与调优：

  • 集成性能监控工具（如 Prometheus + Grafana、New Relic 等），实时监测系统的各项指标，如 CPU 使用率、内存占用、数据库连接数、请求响应时间等。

  • 根据监控数据进行性能分析，找出性能瓶颈，并针对性地进行优化。

  1. 代码优化：

  • 优化数据库操作的代码，避免不必要的查询和重复操作。

  • 对业务逻辑进行重构，提高代码的可读性和可维护性。

  1. 分布式事务处理：
  • 如果涉及多个数据库或服务之间的数据一致性问题，采用合适的分布式事务解决方案（如 TCC、SAGA 等）。
  1. 弹性扩容与缩容：
  • 结合容器化技术（如 Docker、Kubernetes），实现根据系统负载自动扩容或缩容服务器实例，提高资源利用率。
  1. 动静分离：
  • 将静态资源（如图片、CSS、JavaScript 文件）存储在独立的服务器或 CDN 上，加快资源的加载速度。
  1. 安全防护：

  • 加强数据库的访问控制，设置合适的用户权限和密码策略。

  • 防止 SQL 注入、XSS 攻击等常见的安全漏洞。

  1. 测试与压测：

  • 进行单元测试、集成测试和性能测试，确保系统的稳定性和可靠性。

  • 使用压力测试工具（如 JMeter、LoadRunner 等）对系统进行模拟高并发测试，提前发现并解决潜在的性能问题。

好了以上就是用 Java 构建高并发电子商务网站的详细教程，若果有什么不懂的地方，可以随时问老程。接下来会推出更精彩的内容

标签：Java,数据库,并发,详解,static,statement,import,config,连接池
From： https://blog.csdn.net/2401_86187906/article/details/140459130

相关文章

  • 基于Java+SpringBoot+Vue的创新创业教育中心项目申报管理系统的设计与开发(源码+lw+部
    文章目录前言项目背景介绍技术栈后端框架SpringBoot前端框架Vue数据库MySQL（MyStructuredQueryLanguage）具体实现截图详细视频演示系统测试系统测试目的系统功能测试系统测试结论代码参考数据库参考源码获取前言......
  • JavaScript Promise.withResolvers API All In One
    JavaScriptPromise.withResolversAPIAllInOnePromise.withResolvers()https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolversdemoscancelablePromise/cancelFetchrequest(......
  • SpringAOP中的切点表达式Pointcut详解
    https://www.jb51.net/program/293999439.htm 一、概述SpringAOP只支持SpringBean的方法切入，所以切点表达式只会匹配Bean类中的方法。二、切点表达式配置1.内置配置定义切面通知时，在 @Before 或 @AfterReturning 等通知注解中指定表达式。12345......
  • java学习笔记
    //单行注释/**/多行注释/** */文档注释byte:-128~127short:正负三万int：正负21亿long：如果表示的数超过int需要加L 123456789123456Lfloat:后面加fdouble:char:单引号引起来的单个字符增强for循环：for(intnum:arr)创建新的构造器，要保留空构造器，构造器也......
  • 基于 JAVA 的旅游网站设计与实现
    点击下载源码塞北村镇旅游网站设计摘要城市旅游产业的日新月异影响着村镇旅游产业的发展变化。网络、电子科技的迅猛前进同样牵动着旅游产业的快速成长。随着人们消费理念的不断发展变化，越来越多的人开始注意精神文明的追求，而不仅仅只是在意物质消费的提高。塞北村镇旅游......
  • 数据结构（Java）：力扣&牛客 二叉树面试OJ题
    目录1、题一：检查两棵树是否相同 1.1思路分析1.2代码2、题二：另一颗树的子树2.1思路分析 2.2代码3、题三：翻转二叉树3.1思路分析3.2代码4、题四：判断树是否对称4.1思路分析 4.2代码 5、题五：判断是否为平衡二叉树5.1思路分析5.1.1平衡二叉树概念5.1.......
  • 注意力机制中三种掩码技术详解和Pytorch实现
    注意力机制是许多最先进神经网络架构的基本组成部分，比如Transformer模型。注意力机制中的一个关键方面是掩码，它有助于控制信息流，并确保模型适当地处理序列。在这篇文章中，我们将探索在注意力机制中使用的各种类型的掩码，并在PyTorch中实现它们。在神经网络中，掩码是一种用于阻止模......
  • Java中的多线程
    高并发编程的好处多线程可以给程序带来一下好处：1.充分利用CPU资源减少CPU的切换次数，减少CPU的空闲时间，从而最大程度的发挥CPU的运算能力。2.加快用户的响应时间在充分占用多的CPU运算能力的情况下，执行任务就会变得更快速，任务完成时间也就会变短，从而能加快响应时间。3.可以是......
  • JavaScript基础
    JavaScripJavaScript是一种基于对象和事件驱动的、并具有安全性能的脚本语言JavaScript特点1.向HTML页面中添加交互行为2.脚本语言，语法和Java类似3.解释性语言，边执行边解释1.JavaScript组成JavaScript-->ECMAScriptES基础语法JavaScript-->DOMDOM操作HTML元素J......
  • Javascript中的解构操作
    Javascript中的解构操作解构的定义解构的好处一些常用的解构操作总结解构的定义解构（Destructuring）是一种JavaScript表达式，可以将数组或对象中的数据解析到不同的变量中。它使得从复杂的数据结构中提取数据变得更加简洁和方便。解构赋值语法使用花括号{}（对于对象......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99