Question

假设我有一个类根据一组规则验证密码。验证密码的准确程度取决于调用服务器的人员。每种不同类型的人对某些规则都有不同的实现。让我们说，在正常验证中严格验证8中的LengthRule将需要12的长度，而在松散验证中则为5。 根据传递的参数更改所有规则的绑定的最佳方法是什么，例如组布线并动态切换它们？

INSERT INTO TirAliquotaRamoI (DataElaborazione, 
                              TassoLordoAnnuoAppl,
                              TassoGiornaliereNetto, 
                              Aliquota, 
                              DataInizio, 
                              DataFine, 
                              TIMESTAMP)
VALUES ('2015-08-01 00:00:00',
        0,
        0,
        1,
        '2015-08-01 00:00:00',
        '2100-12-32',
        TIMESTAMP);

Answer 1

这是基于Guice中的MultiBindings的答案。概述：您可以将多个实现绑定到给定的接口，然后注入一组实现。

我要做的是绑定我的所有密码检查程序，注入它们然后使用该集来确定要执行的操作。

这是一个完整的运行示例：

public class TestMultiBinding {

    public static void main(String[] args) {

        Injector injector = Guice.createInjector( new AbstractModule() {

            @Override
            protected void configure() {
                Multibinder<PasswordChecker> multiBinder = Multibinder.newSetBinder(binder(), PasswordChecker.class);
                multiBinder.addBinding().to(BusinessChecker.class);
                multiBinder.addBinding().to(ClientChecker.class);

                bind(Test.class).in(Singleton.class);
            }
        });


        Test test = injector.getInstance(Test.class);
        test.verifyPassword("hello", Person.P1);
        test.verifyPassword("hello", Person.P2);
    }

    public static class Test {

        private Set<PasswordChecker> checkers;

        @Inject
        public Test(final Set<PasswordChecker> checker) {
            this.checkers = checker;
        }

        public void verifyPassword(final String pass, final Person p) {
            getPasswordChecker(p).check(pass);
        }

        public PasswordChecker getPasswordChecker(final Person p) {
            Optional<PasswordChecker> checker = checkers.stream().filter(c -> c.isApplicable(p)).findFirst();
            if(checker.isPresent()) {
                return checker.get();
            }
            return null; // or default
        }
    }


    public static interface PasswordChecker {
        public void check(String s);
        boolean isApplicable(Person P);
    }

    public static class BusinessChecker implements PasswordChecker {

        @Override
        public void check(String s) {
            System.out.println("User Business Checker");
        }

        @Override
        public boolean isApplicable(Person P) {
            return P.equals(Person.P1);
        }
    }

    public static class ClientChecker implements PasswordChecker {

        @Override
        public void check(String s) {
            System.out.println("User Client Checker");
        }

        @Override
        public boolean isApplicable(Person P) {
            return P.equals(Person.P2);
        }
    }

    public enum Person {
        P1, P2;
    }
}

Test类就是你的榜样。它需要一个密码和一个Person枚举。

每个PasswordChecker实现一个名为＆＃34; isApplicable＆＃34;的方法。确定给定的人是否可以使用此检查程序。或者，在注入时，您可以将PasswordChecker映射到正确的人（使用stream.collect（Collectors.toMap（...））方法）。这样，您只需要进行哈希映射查找即可获得正确的实现。

在我的模块中，我为密码检查器定义了一个多重绑定。我将绑定添加到它。

你能看到的其余部分。

调用我的代码将打印：

User Business Checker
User Client Checker

我希望这就是你要找的东西:)让我知道！

Artur

更改参数上的Guice配置

1 个答案: