项目搭建：guice,jdbc，maven

当然，以下是一个使用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应用程序。希望这能帮助你开始构建自己的项目。如果有任何问题或需要进一步的帮助，请随时提问！