当然，以下是一个使用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>
<properties>
<java.version>17</java.version>
<guice.version>5.1.0</guice.version>
<mysql.connector.version>8.0.33</mysql.connector.version>
</properties>
<dependencies>
<!-- Guice -->
<dependency>
<groupId>com.google.inject</groupId>
<artifactId>guice</artifactId>
<version>${guice.version}</version>
</dependency>
<!-- MySQL Connector -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.connector.version}</version>
</dependency>
<!-- SLF4J for logging (Optional) -->
<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>
<!-- JUnit for testing (Optional) -->
<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应用程序。希望这能帮助你开始构建自己的项目。如果有任何问题或需要进一步的帮助，请随时提问！