Java Weld类代码示例

import org.jboss.weld.environment.se.Weld; //导入依赖的package包/类
@Override
public Statement apply(final Statement base, final Description description) {
    return new Statement() {
        @Override
        public void evaluate() throws Throwable {
            Weld weld = WeldInitiator.this.weld;
            if (weld == null) {
                // Null in case of fromTestPackage() is used
                weld = createWeld().addPackage(false, description.getTestClass());
            }
            initWeldContainer(weld);
            try {
                base.evaluate();
            } finally {
                shutdownWeldContainer();
            }
        }
    };
}
 

import org.jboss.weld.environment.se.Weld; //导入依赖的package包/类
protected WeldContainer initWeldContainer(Weld weld) {
    // Register mock injection services if needed
    if (!resources.isEmpty()) {
        weld.addServices(new MockResourceInjectionServices(resources));
    }
    if (ejbFactory != null) {
        weld.addServices(new MockEjbInjectionServices(ejbFactory));
    }
    if (persistenceContextFactory != null || persistenceUnitFactory != null) {
        weld.addServices(new MockJpaInjectionServices(persistenceUnitFactory, persistenceContextFactory));
    }
    // Init the container
    container = weld.initialize();
    injectInstances();
    if (extension != null) {
        extension.activateContexts();
    }
    return container;
}
 

import org.jboss.weld.environment.se.Weld; //导入依赖的package包/类
@Test
public void testCommandDecorator() {

    try (WeldContainer container = new Weld()
            // Disable discovery completely
            .disableDiscovery()
            // Add command context implementation, decorator is enabled globally/automatically
            .packages(CommandContext.class)
            // Add bean classes manually
            .beanClasses(DummyService.class, IdService.class, TestCommand.class)
            // Add command extension manually so that we don't need to create META-INF/...
            .addExtension(new CommandExtension())
            .initialize()) {

        // Command is a bean - cotext is activated/deactivated by decorator
        container.select(TestCommand.class).get().execute();
    }

}
 

import org.jboss.weld.environment.se.Weld; //导入依赖的package包/类
@Test
public void testCommandDecorator() {

    try (WeldContainer container = new Weld()
            // Disable discovery completely
            .disableDiscovery()
            // Add command context implementation, decorator is enabled globally/automatically
            .packages(CommandContext.class)
            // Add bean classes manually
            .beanClasses(DummyService.class, IdService.class, TestCommand.class)
            // Add command extension manually so that we don't need to create META-INF/...
            .addExtension(new CommandExtension()).initialize()) {

        // Execute non-CDI bean command - context is activated/deactivated by executor
        CommandExecutor executor = container.select(CommandExecutor.class).get();
        executor.execute(() -> {
            assertEquals(container.select(IdService.class).get().getId(), container.select(IdService.class).get().getId());
        });
    }

}
 

import org.jboss.weld.environment.se.Weld; //导入依赖的package包/类
@Before
public void init(TestContext context) throws InterruptedException {
    weld = new Weld().disableDiscovery().addExtension(new RouteExtension()).beanClasses(HelloHandler.class, SayHelloService.class).initialize();
    vertx = Vertx.vertx();
    Async async = context.async();
    Router router = Router.router(vertx);
    weld.select(RouteExtension.class).get().registerRoutes(router);
    router.route().handler(BodyHandler.create());
    vertx.createHttpServer().requestHandler(router::accept).listen(8080, (r) -> {
        if (r.succeeded()) {
            async.complete();
        } else {
            context.fail(r.cause());
        }
    });
}
 

import org.jboss.weld.environment.se.Weld; //导入依赖的package包/类
@Before
public void init(TestContext context) throws InterruptedException {
    vertx = Vertx.vertx();
    Async async = context.async();
    Weld weld = WeldVerticle.createDefaultWeld().disableDiscovery().beanClasses(HelloRouteObserver.class, PaymentObserverResource.class,
            SayHelloService.class, PaymentService.class, RequestHelloService.class);
    WeldWebVerticle weldVerticle = new WeldWebVerticle(weld);
    vertx.deployVerticle(weldVerticle, deploy -> {
        if (deploy.succeeded()) {
            // Configure the router after Weld bootstrap finished
            vertx.createHttpServer().requestHandler(weldVerticle.createRouter()::accept).listen(8080, (listen) -> {
                if (listen.succeeded()) {
                    async.complete();
                } else {
                    context.fail(listen.cause());
                }
            });
        } else {
            context.fail(deploy.cause());
        }
    });
    SYNCHRONIZER.clear();
}
 

import org.jboss.weld.environment.se.Weld; //导入依赖的package包/类
@Before
public void init(TestContext context) throws InterruptedException {
    vertx = Vertx.vertx();
    Async async = context.async();
    Weld weld = WeldVerticle.createDefaultWeld().disableDiscovery().packages(WebRouteTest.class);
    WeldWebVerticle weldVerticle = new WeldWebVerticle(weld);
    vertx.deployVerticle(weldVerticle, deploy -> {
        if (deploy.succeeded()) {
            // Configure the router after Weld bootstrap finished
            vertx.createHttpServer().requestHandler(weldVerticle.createRouter()::accept).listen(8080, (listen) -> {
                if (listen.succeeded()) {
                    async.complete();
                } else {
                    context.fail(listen.cause());
                }
            });
        } else {
            context.fail(deploy.cause());
        }
    });
    SYNCHRONIZER.clear();
}
 

import org.jboss.weld.environment.se.Weld; //导入依赖的package包/类
@Before
public void init(TestContext context) throws InterruptedException {
    vertx = Vertx.vertx();
    Async async = context.async();
    Weld weld = WeldVerticle.createDefaultWeld().disableDiscovery().beanClasses(AsyncRouteObserver.class, BlockingService.class)
            .packages(AsyncReference.class);
    WeldWebVerticle weldVerticle = new WeldWebVerticle(weld);
    vertx.deployVerticle(weldVerticle, deploy -> {
        if (deploy.succeeded()) {
            // Configure the router after Weld bootstrap finished
            vertx.createHttpServer().requestHandler(weldVerticle.createRouter()::accept).listen(8080, (listen) -> {
                if (listen.succeeded()) {
                    async.complete();
                } else {
                    context.fail(listen.cause());
                }
            });
        } else {
            context.fail(deploy.cause());
        }
    });
    SYNCHRONIZER.clear();
}
 

import org.jboss.weld.environment.se.Weld; //导入依赖的package包/类
@Before
public void init(TestContext context) throws InterruptedException {
    vertx = Vertx.vertx();
    Async async = context.async();
    Weld weld = WeldVerticle.createDefaultWeld().disableDiscovery().beanClasses(BlockingService.class, HelloAsyncHandler.class)
            .packages(AsyncReference.class);
    WeldWebVerticle weldVerticle = new WeldWebVerticle(weld);
    vertx.deployVerticle(weldVerticle, deploy -> {
        if (deploy.succeeded()) {
            // Configure the router after Weld bootstrap finished
            vertx.createHttpServer().requestHandler(weldVerticle.createRouter()::accept).listen(8080, (listen) -> {
                if (listen.succeeded()) {
                    async.complete();
                } else {
                    context.fail(listen.cause());
                }
            });
        } else {
            context.fail(deploy.cause());
        }
    });
    SYNCHRONIZER.clear();
}
 

import org.jboss.weld.environment.se.Weld; //导入依赖的package包/类
@Before
public void init(TestContext context) throws InterruptedException {
    vertx = Vertx.vertx();
    Async async = context.async();
    final WeldWebVerticle weldVerticle = new WeldWebVerticle(createDefaultWeld().property(Weld.DEV_MODE_SYSTEM_PROPERTY, true));
    vertx.deployVerticle(weldVerticle, deploy -> {
        if (deploy.succeeded()) {
            Router router = Router.router(vertx);
            router.route().handler(BodyHandler.create());
            weldVerticle.registerRoutes(router);
            vertx.createHttpServer().requestHandler(router::accept).listen(8080, (listen) -> {
                if (listen.succeeded()) {
                    async.complete();
                } else {
                    listen.cause().printStackTrace();
                }
            });
        } else {
            deploy.cause().printStackTrace();
        }
    });
}
 

import org.jboss.weld.environment.se.Weld; //导入依赖的package包/类
@Override
public void start(Future<Void> startFuture) throws Exception {
    Weld weld = this.weld != null ? this.weld : createDefaultWeld();
    if (weld.getContainerId() == null) {
        weld.containerId(deploymentID());
    }
    weld.addExtension(new VertxExtension(vertx, context));
    configureWeld(weld);
    // Bootstrap can take some time to complete
    vertx.executeBlocking(future -> {
        try {
            this.weldContainer = weld.initialize();
            future.complete();
        } catch (Exception e) {
            future.fail(e);
        }
    }, result -> {
        if (result.succeeded()) {
            LOGGER.info("Weld verticle started for deployment {0}", deploymentID());
            startFuture.complete();
        } else {
            startFuture.fail(result.cause());
        }
    });
}
 

import org.jboss.weld.environment.se.Weld; //导入依赖的package包/类
@Override
public void start(Stage initStage) throws Exception {
    final Stage primaryStage = new Stage(StageStyle.DECORATED);
    Task<ObservableValue<Stage>> mainStageTask = new Task<ObservableValue<Stage>>() {
        @Override
        protected ObservableValue<Stage> call() throws Exception {
            Weld weld = new Weld();
            WeldContainer container = weld.initialize(); // Initialize Weld CDI
            primaryStage.setTitle("StudyGuide");
            primaryStage.setOnCloseRequest(event -> {
                logger.debug("Closing down Weld.");
                weld.shutdown();
            });
            primaryStage.getIcons().add(new Image(StudyGuideApplication.class.getResourceAsStream(logoResource)));
            container.event().select(Stage.class, new AnnotationLiteral<StartupStage>() {
            }).fire(primaryStage);
            return new ReadOnlyObjectWrapper<>(primaryStage);
        }
    };
    mainStageTask.exceptionProperty().addListener((observable, oldValue, newValue) -> {
        Platform.runLater(() -> {
            throw new IllegalStateException("Main stage loading failed.", newValue);
        });
    });
    showSplashScreen(initStage, mainStageTask);
}
 

import org.jboss.weld.environment.se.Weld; //导入依赖的package包/类
@Test
public void testInit() throws InterruptedException {
    /**
     * Some TODOs:
     *
     * 1. Add an extension that observes ProcessAnnotatedType, keeps in a class, and then add a getter to get the list of these that are annotated @Path
     * 2. Override CDIRequestDispatcher to start a request context, and then stop when done.
     *
     */
    BasicConfigurator.configure();
    Weld weld = new Weld();
    weld.initialize();
    LoadPathsExtension paths = CDI.current().select(LoadPathsExtension.class).get();
    CDINettyJaxrsServer netty = new CDINettyJaxrsServer();
    ResteasyDeployment rd = new ResteasyDeployment();
    rd.setActualResourceClasses(paths.getResources());
    rd.setInjectorFactoryClass(CdiInjectorFactory.class.getName());
    netty.setDeployment(rd);
    netty.setPort(8087);
    netty.setRootResourcePath("");
    netty.setSecurityDomain(null);
    netty.start();
    Client c = ClientBuilder.newClient();
    String result = c.target("http://localhost:8087").path("/").request("text/plain").accept("text/plain").get(String.class);
    Assert.assertEquals("pong", result);
}
 

import org.jboss.weld.environment.se.Weld; //导入依赖的package包/类
public void start() throws Exception {
	logger.log(Level.INFO, "stokesdrift:server:start[status=in_progress]");

	logger.log(Level.INFO, "stokesdrift:server:load_cdi_container[status=in_progress]");
	weld = new Weld();
	container = weld.initialize();
	logger.log(Level.INFO, "stokesdrift:server:load_cdi_container[status=complete]");

	applications = loadApplicationDefinitions(config);

	Undertow.Builder builder = Undertow.builder().addHttpListener(config.getPort(), config.getHost());
	List<DeploymentManager> managers = deployApplications(applications);
	for (DeploymentManager deploymentManager : managers) {
		builder.setHandler(deploymentManager.start());
	}
	server = builder.build();
	server.start();
	logger.log(Level.INFO, "stokesdrift:server:http[port="+config.getPort()+",host="+config.getHost()+"]");
	logger.log(Level.INFO, "stokesdrift:server:start[status=complete]");
}
 

import org.jboss.weld.environment.se.Weld; //导入依赖的package包/类
public static void main(String[] args) {
        disableLogging();
        SystemAccess system = new RealSystemAccess();
        new MigrationTool(new ExternalMigrationService(system),
                          new ToolConfig.DefaultFactory(),
                          system,
                          () -> {
                            /*
                             * Work around log4j-api message printed from missing configuration.
                             */
                            PrintStream err = System.err;
//                            System.setErr(new PrintStream(new NullOutputStream()));
                            try {
                                WeldContainer container = new Weld().initialize();
                                return container;
                            } finally {
                                System.setErr(err);
                            }
                        }).run(args);
    }