扩展HK2依赖注入：自定义注解与手动绑定策略

// Service interface
@Contract
public interface UserService {
    void add(User user);
}

// Service implementation
@Service
public class UserServiceImpl implements UserService {
    @Override
    public void add(User user) {
        // ... implementation details ...
    }
}

<dependencies>
    <!-- ... existing dependencies ... -->
    <dependency>
        <groupId>org.reflections</groupId>
        <artifactId>reflections</artifactId>
        <version>0.10.2</version> <!-- 使用最新稳定版本 -->
    </dependency>
    <!-- 如果使用Java 9+，可能需要额外的依赖 -->
    <dependency>
        <groupId>org.javassist</groupId>
        <artifactId>javassist</artifactId>
        <version>3.28.0-GA</version>
    </dependency>
</dependencies>

// src/main/java/com/example/annotations/Repository.java
package com.example.annotations;

import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
public @interface Repository {
}

// src/main/java/com/example/annotations/BeanAddress.java
package com.example.annotations;

import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface BeanAddress {
    String implPackageName(); // 用于存储实现类的全限定名
}

// src/main/java/com/example/dao/UserDao.java
package com.example.dao;

import com.example.annotations.BeanAddress;
import com.example.annotations.Repository;
import com.example.model.User;

@Repository
@BeanAddress(implPackageName = "com.example.dao.impl.UserDaoImpl")
public interface UserDao {
    void save(User user);
}

// src/main/java/com/example/dao/impl/UserDaoImpl.java
package com.example.dao.impl;

import com.example.dao.UserDao;
import com.example.model.User;
import jakarta.inject.Singleton; // 标记为单例，但这不是HK2自动扫描的关键

@Singleton // 这里的@Singleton仅表示生命周期，而非被HK2扫描的触发器
public class UserDaoImpl implements UserDao {
    @Override
    public void save(User user) {
        System.out.println("Saving user: " + user.getName());
        // ... actual database logic ...
    }
}

// src/main/java/com/example/config/CustomRepositoryBinder.java
package com.example.config;

import com.example.annotations.BeanAddress;
import com.example.annotations.Repository;
import jakarta.inject.Singleton;
import org.glassfish.hk2.utilities.binding.AbstractBinder;
import org.reflections.Reflections;

import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;

public class CustomRepositoryBinder extends AbstractBinder {

    private static final Logger LOGGER = Logger.getLogger(CustomRepositoryBinder.class.getName());
    private final String packageName;

    public CustomRepositoryBinder(String packageName) {
        this.packageName = packageName;
    }

    @Override
    protected void configure() {
        LOGGER.info("Starting HK2 custom binder configuration for package: " + packageName);

        // 使用Reflections扫描指定包下所有带有@Repository注解的接口
        Reflections reflections = new Reflections(packageName);
        Set<Class<?>> repositories = reflections.getTypesAnnotatedWith(Repository.class, true);

        repositories.forEach(repoInterface -> {
            // 确保接口有BeanAddress注解来指定实现类
            if (repoInterface.isAnnotationPresent(BeanAddress.class)) {
                BeanAddress beanAddress = repoInterface.getAnnotation(BeanAddress.class);
                String implClassName = beanAddress.implPackageName();

                try {
                    Class<?> implClass = Class.forName(implClassName);
                    // 绑定实现类到接口，并指定为单例作用域
                    // .to(repoInterface) 表示将实现类作为 repoInterface 的实现提供
                    // .in(Singleton.class) 表示此实例为单例
                    // .named(...) 可以用于命名绑定，如果需要特定名称的实例
                    bind(implClass).to(repoInterface).in(Singleton.class);
                    LOGGER.info(String.format("Bound repository: %s to implementation: %s as Singleton",
                            repoInterface.getName(), implClass.getName()));
                } catch (ClassNotFoundException e) {
                    LOGGER.log(Level.SEVERE, "Implementation class not found for repository: "
                            + repoInterface.getName() + " with impl name: " + implClassName, e);
                    throw new RuntimeException("Failed to bind repository due to missing implementation class.", e);
                }
            } else {
                LOGGER.warning("Repository interface " + repoInterface.getName() + " is missing @BeanAddress annotation.");
            }
        });

        LOGGER.info("Finished HK2 custom binder configuration.");
    }
}

// src/main/java/com/example/MyApplication.java
package com.example;

import com.example.config.CustomRepositoryBinder;
import jakarta.ws.rs.ApplicationPath;
import org.glassfish.jersey.server.ResourceConfig;

@ApplicationPath("/")
public class MyApplication extends ResourceConfig {

    public MyApplication() {
        // 注册Jersey资源类所在的包
        packages("com.example.resource");

        // 注册HK2自动扫描Feature (如果需要，用于@Service和@Contract)
        register(new AutoScanFeature()); // 假设AutoScanFeature是您已有的自动扫描配置

        // 注册自定义的Repository Binder
        // 传入需要扫描的包名，通常是DAO接口所在的包
        register(new CustomRepositoryBinder("com.example.dao"));

        // 注册其他组件，例如Jackson JSON provider
        register(org.glassfish.jersey.media.json.jackson.JacksonFeature.class);
    }
}

// src/main/java/com/example/resource/MyResource.java
package com.example.resource;

import com.example.dao.UserDao;
import com.example.model.User;
import jakarta.inject.Inject;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;

@Path("/users")
public class MyResource {

    @Inject
    private UserDao userDao; // 现在可以注入UserDao了

    @GET
    @Path("/add")
    @Produces(MediaType.TEXT_PLAIN)
    public String addUser() {
        User newUser = new User("John Doe");
        userDao.save(newUser);
        return "User added successfully!";
    }
}