Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0301· OpenAIAi2 WildChat-4.8M (AI2)

spring 一个接口,有多个实现类,但是调用的时候,注入的接口,怎么知道调用的是哪个实现类

  1. User

    spring 一个接口,有多个实现类,但是调用的时候,注入的接口,怎么知道调用的是哪个实现类

  2. Assistant

    可以通过在注入时使用@Qualifier注解进行区分。如下所示:

    public interface ExampleInterface {
        void doSomething();
    }
    
    @Service("example1")
    public class Example1Impl implements ExampleInterface {
        @Override
        public void doSomething() {
            System.out.println("Example1Impl doing something");
        }
    }
    
    @Service("example2")
    public class Example2Impl implements ExampleInterface {
        @Override
        public void doSomething() {
            System.out.println("Example2Impl doing something");
        }
    }
    
    @Service
    public class ExampleService {
        @Autowired
        @Qualifier("example1")
        private ExampleInterface example1;
    
        @Autowired
        @Qualifier("example2")
        private ExampleInterface example2;
        
        public void performActions() {
            example1.doSomething(); // prints: Example1Impl doing something
            example2.doSomething(); // prints: Example2Impl doing something
        }
    }
    

    在此示例中,使用了@Qualifier注解来指定调用哪个实现类。通过将不同的@Qualifier注解分配给不同的实现类,可以确保在调用接口的实现类时选择正确的实现类。在ExampleService类中的performActions方法中,示例1和示例2对象在被调用时会输出不同的消息来区分不同的实现类。

  3. User

    换一个

  4. Assistant

    另外一种方式是使用@Configuration注解的方式来标识Bean,并在@Bean注解中指定实现类的类型。如下所示:

    public interface ExampleInterface {
        void doSomething();
    }
    
    @Service("example1")
    public class Example1Impl implements ExampleInterface {
        @Override
        public void doSomething() {
            System.out.println("Example1Impl doing something");
        }
    }
    
    @Service("example2")
    public class Example2Impl implements ExampleInterface {
        @Override
        public void doSomething() {
            System.out.println("Example2Impl doing something");
        }
    }
    
    @Configuration
    public class ExampleConfiguration {
        @Bean(name = "example1")
        public ExampleInterface example1() {
            return new Example1Impl();
        }
    
        @Bean(name = "example2")
        public ExampleInterface example2() {
            return new Example2Impl();
        }
    }
    
    @Service
    public class ExampleService {
        @Autowired
        @Qualifier("example1")
        private ExampleInterface example1;
    
        @Autowired
        @Qualifier("example2")
        private ExampleInterface example2;
        
        public void performActions() {
            example1.doSomething(); // prints: Example1Impl doing something
            example2.doSomething(); // prints: Example2Impl doing something
        }
    }
    

    在此示例中,使用了@Configuration注解来构建Bean,并在@Bean注解中指定实现类的类型。然后在进行注入时,使用@Qualifier注解来区分不同的实现类。这种方式可以使代码更清晰和易于管理,并且在维护更大型的应用程序时非常有用。

  5. User

    @Qualifier,不使用这个注解

  6. Assistant

    如果您不想使用@Qualifier注解,可以使用@Component注解来指定bean的名称,并使用@Autowired注解将其注入到其他类中。如下所示:

    public interface ExampleInterface {
        void doSomething();
    }
    
    @Component("example1") // 或者 @Service("example1")
    public class Example1Impl implements ExampleInterface {
        @Override
        public void doSomething() {
            System.out.println("Example1Impl doing something");
        }
    }
    
    @Component("example2") // 或者 @Service("example2")
    public class Example2Impl implements ExampleInterface {
        @Override
        public void doSomething() {
            System.out.println("Example2Impl doing something");
        }
    }
    
    @Service
    public class ExampleService {
        @Autowired
        private ExampleInterface example1;
    
        @Autowired
        private ExampleInterface example2;
        
        public void performActions() {
            example1.doSomething(); // prints: Example1Impl doing something
            example2.doSomething(); // prints: Example2Impl doing something
        }
    }
    

    在此示例中,使用@Component注解来标识两个不同的实现类,并将它们命名为"example1"和"example2"。在ExampleService类中,使用@Autowired注解将这两个实现类注入到实例变量example1和example2中。没有使用@Qualifier注解,但是如果存在多个实现类,则需要确保它们的名称与将要注入的变量名称一致,否则Spring框架将无法确定应该注入哪个实例。

  7. User

    一个登录方式接口有两个实现类,一个是用户名密码登录,一个是短信登录实现类,怎么根据调用参数,动态实现调用哪个登录实现类

  8. Assistant

    可以通过传递参数的方式,根据不同参数值调用不同的实现类。可以使用@Qualifier注解在每个实现类的@Bean或@Service注解中指定一个唯一的名称,并使用@Value注解将参数值注入到需要使用的类中。如下所示:

    public interface LoginService {
        void login(String account, String password);
    }
    
    @Service("username")
    public class UsernamePasswordLoginServiceImpl implements LoginService {
        @Override
        public void login(String account, String password) {
            System.out.println("UsernamePasswordLoginServiceImpl: " + account + " is logging in with password");
        }
    }
    
    @Service("sms")
    public class SmsLoginServiceImpl implements LoginService {
        @Override
        public void login(String account, String password) {
            System.out.println("SmsLoginServiceImpl: " + account + " is logging in with sms code");
        }
    }
    
    @Service
    public class LoginController {
        @Autowired
        @Qualifier("username")
        private LoginService usernameLoginService;
    
        @Autowired
        @Qualifier("sms")
        private LoginService smsLoginService;
    
        public void login(String type, String account, String password) {
            if ("username".equals(type)) {
                usernameLoginService.login(account, password);
            } else if ("sms".equals(type)) {
                smsLoginService.login(account, password);
            } else {
                throw new IllegalArgumentException("Invalid login type: " + type);
            }
        }
    }
    

    在此示例中,定义了一个LoginService接口和两个实现类UsernamePasswordLoginServiceImpl和SmsLoginServiceImpl。在登录控制器LoginController中,使用@Qualifier注解将每个实现类的名称定义为"username"和"sms"。在login方法中对传递的type参数进行判断,决定应该调用哪个实现类,实现动态的调用不同的实现类。

  9. User

    但是注入Bean的时候用的是 @Autowired private LoginService loginService; 这个方式怎么实现根据参数选择对应的实现类

  10. Assistant

    您可以通过@Bean注解来创建一个工厂类,来动态返回不同的实现类。可以使用@Value注解来获取外部配置文件中的值,然后在工厂类中根据配置返回不同的实现类。如下所示:

    @Configuration
    public class LoginConfig {
        @Value("${login.type:username}") // 默认使用用户名密码登录方式
        private String loginType;
        
        @Bean
        public LoginService loginService() {
            if ("username".equals(loginType)) {
                return new UsernamePasswordLoginServiceImpl();
            } else if ("sms".equals(loginType)) {
                return new SmsLoginServiceImpl();
            } else {
                throw new IllegalArgumentException("Invalid login type: " + loginType);
            }
        }
    }
    
    @Service
    public class LoginController {
        @Autowired
        private LoginService loginService;
        
        public void login(String account, String password) {
            loginService.login(account, password);
        }
    }
    

    在此示例中,定义了一个LoginConfig类,并在其中使用@Bean注解创建一个工厂类,根据传入的type参数值创建不同的LoginService实例。通过@Value注解来获取配置文件中的login.type值,根据该值决定使用哪种登录方式。在LoginController中,将LoginService实例注入进来并调用它的login方法。这样,登录控制器就可以根据外部参数动态选择使用哪种登录方式。

  11. User

    没有 @Value(“${login.type:username}”) 根据接口参数,如何选择对应的实现类

  12. Assistant

    如果需要根据接口参数选择相应的实现类,可以在工厂方法中接收一个参数,根据参数来返回不同的实现类。如下所示:

    public interface LoginService {
        void login(String account, String password);
    }
    
    @Service("username")
    public class UsernamePasswordLoginServiceImpl implements LoginService {
        @Override
        public void login(String account, String password) {
            System.out.println("UsernamePasswordLoginServiceImpl: " + account + " is logging in with password");
        }
    }
    
    @Service("sms")
    public class SmsLoginServiceImpl implements LoginService {
        @Override
        public void login(String account, String password) {
            System.out.println("SmsLoginServiceImpl: " + account + " is logging in with sms code");
        }
    }
    
    @Configuration
    public class LoginConfig {
        @Bean
        public LoginService loginService(String loginType) {
            if ("username".equals(loginType)) {
                return new UsernamePasswordLoginServiceImpl();
            } else if ("sms".equals(loginType)) {
                return new SmsLoginServiceImpl();
            } else {
                throw new IllegalArgumentException("Invalid login type: " + loginType);
            }
        }
    }
    
    @Service
    public class LoginController {
        @Autowired
        private ApplicationContext context;
    
        public void login(String type, String account, String password) {
            LoginService loginService = (LoginService) context.getBean("loginService", type);
            loginService.login(account, password);
        }
    }
    

    在此示例中,定义了一个LoginConfig类,并在其中使用@Bean注解创建一个工厂类,根据loginType参数值创建不同的LoginService实例。在LoginController中,根据type参数值从ApplicationContext中获取loginService实例,并调用它的login方法。这样,登录控制器就可以根据传入的参数动态选择使用哪种登录方式。

  13. User

    换一个解决方案

  14. Assistant

    另一种方案是使用Spring的策略模式,将不同的登录方式实现类放到一个Map中,根据传入的参数值选择相应的实现类来执行。如下所示:

    public interface LoginService {
        void login(String account, String password);
    }
    
    @Service("username")
    public class UsernamePasswordLoginServiceImpl implements LoginService {
        @Override
        public void login(String account, String password) {
            System.out.println("UsernamePasswordLoginServiceImpl: " + account + " is logging in with password");
        }
    }
    
    @Service("sms")
    public class SmsLoginServiceImpl implements LoginService {
        @Override
        public void login(String account, String password) {
            System.out.println("SmsLoginServiceImpl: " + account + " is logging in with sms code");
        }
    }
    
    @Service
    public class LoginServiceFactory {
        @Autowired
        private Map<String, LoginService> loginServiceMap;
    
        public LoginService getLoginService(String type) {
            if (loginServiceMap.containsKey(type)) {
                return loginServiceMap.get(type);
            } else {
                throw new IllegalArgumentException("Invalid login type: " + type);
            }
        }
    }
    
    @Service
    public class LoginController {
        @Autowired
        private LoginServiceFactory loginServiceFactory;
    
        public void login(String type, String account, String password) {
            LoginService loginService = loginServiceFactory.getLoginService(type);
            loginService.login(account, password);
        }
    }
    

    在此示例中,定义了一个LoginServiceFactory类,并注入一个Map类型的loginServiceMap。使用@Service注解标注LoginServiceFactory为Spring管理的Bean,并将不同的登录方式实现类放入loginServiceMap中进行管理。在LoginController中,根据type参数值调用LoginServiceFactory的getLoginService方法,从loginServiceMap中获取相应的实现类来处理登录请求。

    这种方式避免了在工厂方法中对每个实现类都进行了硬编码,易于扩展和管理。同时避免了使用反射 API 的情况,也可以避免因使用反射带来的性能问题。

  15. User

    上述的的实现类Bean是怎么注入到loginServiceMap中的

  16. Assistant

    在上述的实现中,通过使用Spring的泛型注入功能,对Map进行了注入,使得Map的key为Bean的名称,value为Bean的实例。具体实现如下:

    @Service
    public class LoginServiceFactory {
        @Autowired
        private Map<String, LoginService> loginServiceMap;
        
        // ...
    }
    

    在LoginServiceFactory类中,使用@Autowired注解来注入Map<String, LoginService>类型的loginServiceMap变量。Spring会扫描所有实现了LoginService接口的类,将它们自动注入到Map中。其中,Map中的String类型的key来自于每个Bean的名称,而LoginService类型的value来自于Bean实例。例如,在@Configuration或@Service注解的类中,使用@Bean或@Service注解定义Bean时,可以使用value属性来指定Bean的名称。在这种情况下,Bean的名称将作为Map中键的值。而默认情况下,Spring会使用类名的首字母小写形式作为默认的Bean名称。所以,在我们的示例中,Spring将UsernamePasswordLoginServiceImpl和SmsLoginServiceImpl类的实例作为Map的值注入到loginServiceMap中,key分别为"username"和"sms"。

  17. User

    如何在UsernamePasswordLoginServiceImpl和SmsLoginServiceImpl初始化结束之后,放入loginServiceMap中

  18. Assistant

    您可以通过实现ApplicationListener<ContextRefreshedEvent>接口,监听Spring的上下文刷新事件,在所有Bean初始化完成之后进行登录Service的注入。代码示例如下:

    @Service("username")
    public class UsernamePasswordLoginServiceImpl implements LoginService, ApplicationListener<ContextRefreshedEvent> {
    
        private LoginServiceFactory loginServiceFactory;
    
        @Override
        public void login(String account, String password) {
            System.out.println("UsernamePasswordLoginServiceImpl: " + account + " is logging in with password");
        }
    
        @Override
        public void onApplicationEvent(ContextRefreshedEvent event) {
            if (loginServiceFactory != null) {
                loginServiceFactory.putLoginService("username", this);
            }
        }
    
        @Autowired
        public void setLoginServiceFactory(LoginServiceFactory loginServiceFactory) {
            this.loginServiceFactory = loginServiceFactory;
        }
    }
    
    @Service("sms")
    public class SmsLoginServiceImpl implements LoginService, ApplicationListener<ContextRefreshedEvent> {
    
        private LoginServiceFactory loginServiceFactory;
    
        @Override
        public void login(String account, String password) {
            System.out.println("SmsLoginServiceImpl: " + account + " is logging in with sms code");
        }
    
        @Override
        public void onApplicationEvent(ContextRefreshedEvent event) {
            if (loginServiceFactory != null) {
                loginServiceFactory.putLoginService("sms", this);
            }
        }
    
        @Autowired
        public void setLoginServiceFactory(LoginServiceFactory loginServiceFactory) {
            this.loginServiceFactory = loginServiceFactory;
        }
    }
    
    @Service
    public class LoginServiceFactory {
    
        private final Map<String, LoginService> loginServiceMap = new ConcurrentHashMap<>();
    
        @Autowired
        public void init(Map<String, LoginService> loginServiceMap) {
            loginServiceMap.forEach(this::putLoginService);
        }
    
        public LoginService getLoginService(String type) {
            LoginService loginService = loginServiceMap.get(type);
            if (loginService == null) {
                throw new IllegalArgumentException("Invalid login type: " + type);
            }
            return loginService;
        }
    
        public void putLoginService(String type, LoginService loginService) {
            loginServiceMap.put(type, loginService);
        }
    }
    
    @Service
    public class LoginController {
        
        private final LoginServiceFactory loginServiceFactory;
    
        @Autowired
        public LoginController(LoginServiceFactory loginServiceFactory) {
            this.loginServiceFactory = loginServiceFactory;
        }
    
        public void login(String type, String account, String password) {
            LoginService loginService = loginServiceFactory.getLoginService(type);
            loginService.login(account, password);
        }
    }
    

    在实现类UsernamePasswordLoginServiceImpl和SmsLoginServiceImpl中,实现了ApplicationListener<ContextRefreshedEvent>接口,并重写了onApplicationEvent方法。在方法内部,判断LoginServiceFactory实例是否不为空,并将当前实例对象(即实现了当前Bean的类的实例)放入到loginServiceMap中。在实现中,使用了注入方式来将LoginServiceFactory实例注入到实现类中。

    在LoginServiceFactory类中,使用init方法,并将Map<String, LoginService>类型的依赖注入到该方法中。在方法内部,使用putLoginService方法将Map中的键值对存入到当前类实例的loginServiceMap成员变量中。

    在LoginController类中,通过构造函数将LoginServiceFactory实例注入,并使用该实例中的getLoginService方法获取对应的实现类实例执行登录操作。

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.