当前位置：首页 > article >正文

项目搭建：guice,jdbc，maven

article 2025/3/7 8:16:34

当然，以下是一个使用Guice、JDBC和Maven实现接口项目的具体例子。这个项目将展示如何创建一个简单的用户管理应用，包括用户信息的增删改查（CRUD）操作。

### 1. Maven `pom.xml` 文件

首先确保你的`pom.xml`文件包含必要的依赖：

```xml
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>guice-jdbc-maven</artifactId>
<version>1.0-SNAPSHOT</version>

<dependencies>

<dependency>
<groupId>com.google.inject</groupId>
<artifactId>guice</artifactId>
<version>${guice.version}</version>
</dependency>

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.connector.version}</version>
</dependency>

<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.36</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
<version>1.7.36</version>
</dependency>

<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
</dependencies>

<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>${java.version}</source>
<target>${java.version}</target>
</configuration>
</plugin>
</plugins>
</build>
</project>
```

### 2. 创建数据源提供者 `DataSourceProvider.java`

创建一个类来配置和提供数据库连接：

```java
package com.example.provider;

import com.google.inject.Provider;
import javax.sql.DataSource;
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;

public class DataSourceProvider implements Provider<DataSource> {
@Override
public DataSource get() {
HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb");
config.setUsername("root");
config.setPassword("password");
config.addDataSourceProperty("cachePrepStmts", "true");
config.addDataSourceProperty("prepStmtCacheSize", "250");
config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");
return new HikariDataSource(config);
}
}
```

### 3. 定义实体类 `User.java`

定义一个简单的用户实体类：

```java
package com.example.model;

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

// Constructors, Getters and Setters
public User() {}

public User(Integer id, String username, String password) {
this.id = id;
this.username = username;
this.password = password;
}

// Getters and Setters...
}
```

### 4. 创建DAO接口 `UserDao.java`

定义一个用于与数据库交互的接口：

```java
package com.example.dao;

import com.example.model.User;

import java.util.List;

public interface UserDao {
void save(User user);
void update(User user);
void delete(int id);
User findById(int id);
List<User> findAll();
}
```

### 5. 实现DAO `UserDaoImpl.java`

实现上述接口，并编写具体的SQL逻辑：

```java
package com.example.dao.impl;

import com.example.dao.UserDao;
import com.example.model.User;
import com.google.inject.Inject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.sql.DataSource;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;

public class UserDaoImpl implements UserDao {

private static final Logger logger = LoggerFactory.getLogger(UserDaoImpl.class);

private final DataSource dataSource;

@Inject
public UserDaoImpl(DataSource dataSource) {
this.dataSource = dataSource;
}

@Override
public void save(User user) {
try (Connection conn = dataSource.getConnection();
PreparedStatement pstmt = conn.prepareStatement(
"INSERT INTO users(username, password) VALUES (?, ?)",
Statement.RETURN_GENERATED_KEYS)) {

pstmt.setString(1, user.getUsername());
pstmt.setString(2, user.getPassword());

int affectedRows = pstmt.executeUpdate();
if (affectedRows > 0) {
try (ResultSet rs = pstmt.getGeneratedKeys()) {
if (rs.next()) {
user.setId(rs.getInt(1));
}
}
}
} catch (SQLException e) {
logger.error("Error saving user", e);
}
}

// Implement other methods similarly...

@Override
public List<User> findAll() {
List<User> users = new ArrayList<>();
try (Connection conn = dataSource.getConnection();
PreparedStatement pstmt = conn.prepareStatement("SELECT * FROM users");
ResultSet rs = pstmt.executeQuery()) {

while (rs.next()) {
User user = new User(
rs.getInt("id"),
rs.getString("username"),
rs.getString("password")
);
users.add(user);
}
} catch (SQLException e) {
logger.error("Error finding all users", e);
}
return users;
}
}
```

### 6. 创建服务层 `UserService.java`

定义一个服务层来处理业务逻辑：

```java
package com.example.service;

import com.example.dao.UserDao;
import com.example.model.User;
import com.google.inject.Inject;

import java.util.List;

public class UserService {
private final UserDao userDao;

@Inject
public UserService(UserDao userDao) {
this.userDao = userDao;
}

public void createUser(User user) {
userDao.save(user);
}

public void updateUser(User user) {
userDao.update(user);
}

public void deleteUser(int id) {
userDao.delete(id);
}

public User getUserById(int id) {
return userDao.findById(id);
}

public List<User> getAllUsers() {
return userDao.findAll();
}
}
```

### 7. 配置Guice模块 `AppModule.java`

配置Guice以管理依赖注入：

```java
package com.example.config;

import com.example.dao.UserDao;
import com.example.dao.impl.UserDaoImpl;
import com.example.provider.DataSourceProvider;
import com.example.service.UserService;
import com.google.inject.AbstractModule;

public class AppModule extends AbstractModule {
@Override
protected void configure() {
bind(DataSourceProvider.class).asEagerSingleton();
bind(UserDao.class).to(UserDaoImpl.class);
bind(UserService.class);
}
}
```

### 8. 应用程序入口 `Main.java`

创建应用程序入口点并初始化Guice：

```java
package com.example;

import com.example.config.AppModule;
import com.example.service.UserService;
import com.google.inject.Guice;
import com.google.inject.Injector;

public class Main {
public static void main(String[] args) {
Injector injector = Guice.createInjector(new AppModule());
UserService userService = injector.getInstance(UserService.class);

// 使用userService进行CRUD操作...
// 示例：userService.createUser(new User(null, "john_doe", "password"));
}
}
```

### 注意事项
- 确保你已经正确设置了数据库表结构，例如`users`表应该有`id`, `username`, 和`password`字段。
- 根据实际情况调整包名、路径以及其他细节。
- 如果你打算在生产环境中使用，请考虑更安全的密码存储方式（如加密或哈希），以及更复杂的错误处理机制。

以上代码示例展示了如何使用Guice和JDBC构建一个简单的Java应用程序。希望这能帮助你开始构建自己的项目。如果有任何问题或需要进一步的帮助，请随时提问！

查看全文

http://www.kler.cn/a/427643.html