Java JPAApi类代码示例

import play.db.jpa.JPAApi; //导入依赖的package包/类
private void populaCidadaos(JPAApi jpaAPI, CidadaoDAO dao, String adminEmail, Integer numeroDeCidadaos) {
	Logger.info("Populando cidadãos.");
	jpaAPI.withTransaction(() -> {
           Cidadao admin = dao.findByLogin(adminEmail);
           if (admin == null) {
               Cidadao cidadao = new Cidadao("Governo Federal", adminEmail);
               cidadao.setFuncionario(true);
               cidadao.setMinisterioDeAfiliacao("Governo Federal");
			admin = dao.saveAndUpdate(cidadao);
			
			// Usuários para demonstração
               for(int i = 0; i < numeroDeCidadaos; i++ ){
               	Cidadao cidadaoParaDemonstracao = new Cidadao("Anônimo", String.format("cidadao_%[email protected]", i));
               	cidadaoParaDemonstracao.setUrlDaFoto("http://www.gravatar.com/avatar/" + cidadaoParaDemonstracao.getLogin().hashCode()
						+ "?f=y&d=retro");
				cidadaos.add(dao.saveAndUpdate(cidadaoParaDemonstracao).getId());
               }
			Logger.info(numeroDeCidadaos + " cidadãos mais o admin cadastrados.");
           } else {
			Logger.info("Admin já cadastrado, assumimos que já temos usuários");
		}
       });
}
 

import play.db.jpa.JPAApi; //导入依赖的package包/类
@Before
public void limpaBancoParaTestes() {
	CidadaoDAO cidadaoDAO = app.injector().instanceOf(CidadaoDAO.class);
	Configuration configuration = app.injector().instanceOf(Configuration.class);
	JPAApi jpaAPI = app.injector().instanceOf(JPAApi.class);
	jpaAPI.withTransaction(() -> {
		String adminEmail = configuration.getString(Cidadao.ADMIN_EMAIL);
		Cidadao cidadao = cidadaoDAO.findByLogin(adminEmail);
		cidadao.setIniciativasAcompanhadas(new HashSet<>());
	});
	
	
	Cidade cidadeTeste = new Cidade(CIDADE_TESTE, "Pasárgada", "PB", 1f, 1f, 1f, 1f, 1000L, 1f, 1f, 0f);
	Iniciativa iniciativaTeste = new Iniciativa(INICIATIVA_TESTE, 2015, "iniciativa para melhorar condições da cidade", "programa do governo federal", "area de atuação", "fonte", "concedente", "status", false, 1000f, 1000f, new Date(), new Date(), new Date());
	cidadeTeste.addIniciativa(iniciativaTeste, new Date(), false);
	
	CidadeDAO cidadeDAO = app.injector().instanceOf(CidadeDAO.class);
	jpaAPI.withTransaction(() ->{
		if(cidadeDAO.find(-1L) == null){
			cidadeDAO.save(cidadeTeste);
		}
	});
}
 

import play.db.jpa.JPAApi; //导入依赖的package包/类
@Before
  public void setUp() {
      this.controller = app.injector().instanceOf(OpiniaoController.class);
      this.jpaAPI = app.injector().instanceOf(JPAApi.class);
      this.daoOpiniao = app.injector().instanceOf(OpiniaoDAO.class);
      
Cidade cidadeTeste = new Cidade(CIDADE_TESTE, "Pasárgada", "PB", 1f, 1f, 1f, 1f, 1000L, 1f, 1f, 0f);
Iniciativa iniciativaTeste = new Iniciativa(INICIATIVA_TESTE, 2015, "iniciativa para melhorar condições da cidade", "programa do governo federal", "area de atuação", "fonte", "concedente", "status", false, 1000f, 1000f, new Date(), new Date(), new Date());
cidadeTeste.addIniciativa(iniciativaTeste, new Date(), false);

CidadeDAO cidadeDAO = app.injector().instanceOf(CidadeDAO.class);
jpaAPI.withTransaction(() ->{
	if(cidadeDAO.find(-1L) == null){
		cidadeDAO.save(cidadeTeste);
	}
});

  }
 

import play.db.jpa.JPAApi; //导入依赖的package包/类
@Before
  public void autenticaAdmin() throws JOSEException{
  	
  	admin = app.injector().instanceOf(JPAApi.class).withTransaction(()->{
  		Configuration configuration = app.injector().instanceOf(Configuration.class);
  		String adminEmail = configuration.getString(Cidadao.ADMIN_EMAIL);
  		CidadaoDAO cidadaoDAO = app.injector().instanceOf(CidadaoDAO.class);
  		if(cidadaoDAO.findByLogin(adminEmail) == null){
  			Cidadao cidadao = new Cidadao("Governo Federal", adminEmail);
              cidadao.setFuncionario(true);
              cidadao.setMinisterioDeAfiliacao("Governo Federal");
		return cidadaoDAO.saveAndUpdate(cidadao);
  		}
  		return cidadaoDAO.findByLogin(adminEmail);
  	});
  	
  	AuthUtils authenticator = app.injector().instanceOf(AuthUtils.class);
token = authenticator.createToken("localhost", admin).getToken();
  	builder = new RequestBuilder().header("authorization", "token " + token);
  }
 

import play.db.jpa.JPAApi; //导入依赖的package包/类
@Before
  public void preparaBancoParaTeste() {
cidadaosCobaia = new LinkedList<>();
      cidadaosCobaia.add(new Cidadao("root maria", "[email protected]"));
      cidadaosCobaia.add(new Cidadao("raquel maria", "[email protected]"));
      cidadaosCobaia.add(new Cidadao("toinho", "[email protected]"));

      controller = app.injector().instanceOf(CidadaoController.class);
      jpaAPI = app.injector().instanceOf(JPAApi.class);
      limpaBanco();
      jpaAPI.withTransaction(() -> {
          for (Cidadao c:
                  cidadaosCobaia) {
              controller.criaCidadao(c);
          }
      });
  }
 

import play.db.jpa.JPAApi; //导入依赖的package包/类
@Inject
public AccountManager(ElasticsearchService elasticsearchService,
        PostManager postManager,
        GroupManager groupManager,
        GroupAccountManager groupAccountManager,
        FriendshipManager friendshipManager,
        MediaManager mediaManager,
        NotificationManager notificationManager,
        AvatarManager avatarManager,
        FolderManager folderManager,
        Configuration configuration, JPAApi jpaApi) {
        this.elasticsearchService = elasticsearchService;
    this.postManager = postManager;
    this.groupManager = groupManager;
    this.groupAccountManager = groupAccountManager;
    this.friendshipManager = friendshipManager;
    this.mediaManager = mediaManager;
    this.notificationManager = notificationManager;
    this.avatarManager = avatarManager;
    this.folderManager = folderManager;
    this.configuration = configuration;
    this.jpaApi = jpaApi;
}
 

import play.db.jpa.JPAApi; //导入依赖的package包/类
@Inject
public EmailService(Configuration configuration,
                    MailerClient mailerClient,
                    Email email,
                    NotificationManager notificationManager,
                    JPAApi jpaApi,
                    MessagesApi messagesApi) {
    this.configuration = configuration;
    this.mailerClient = mailerClient;
    this.email = email;
    this.notificationManager = notificationManager;
    this.jpaApi = jpaApi;
    this.messagesApi = messagesApi;

    this.EMAIL_SENDER = configuration.getString("htwplus.email.sender");


}
 

import play.db.jpa.JPAApi; //导入依赖的package包/类
@Inject public BaseJobService(JPAApi jpaApi, Configuration configuration,
    RemoteModelService<VirtualMachine> virtualMachineModelService, CloudService cloudService,
    ModelService<Tenant> tenantModelService, RemoteModelService<Instance> instanceModelService,
    @Named("jobQueue") SimpleBlockingQueue<Job> jobQueue, KeyPairStrategy keyPairStrategy,
    RemoteConnectionStrategy.RemoteConnectionStrategyFactory remoteConnectionStrategyFactory,
    PortProvidedService portProvidedService, ModelValidationService modelValidationService,
    ModelService<MonitorInstance> monitorInstanceModelService, ModelService<RawMonitor> rawMonitorModelService) {
    this.virtualMachineModelService = virtualMachineModelService;
    this.tenantModelService = tenantModelService;
    this.instanceModelService = instanceModelService;
    this.keyPairStrategy = keyPairStrategy;
    this.remoteConnectionStrategyFactory = remoteConnectionStrategyFactory;
    this.portProvidedService = portProvidedService;
    this.modelValidationService = modelValidationService;
    this.colosseumComputeService = cloudService.computeService();
    this.jobQueue = jobQueue;
    this.configuration = configuration;
    this.jpaApi = jpaApi;
    this.monitorInstanceModelService = monitorInstanceModelService;
    this.rawMonitorModelService = rawMonitorModelService;
}
 

import play.db.jpa.JPAApi; //导入依赖的package包/类
public CreateInstanceJob(Configuration configuration, JPAApi jpaApi, Instance instance,
    RemoteModelService<Instance> modelService, ModelService<Tenant> tenantModelService,
    ColosseumComputeService colosseumComputeService, Tenant tenant,
    ModelValidationService modelValidationService) {
    super(jpaApi, instance, modelService, tenantModelService, colosseumComputeService, tenant);

    checkNotNull(modelValidationService);
    checkNotNull(configuration);

    this.modelValidationService = modelValidationService;
    applicationToApplicationId = new ApplicationToApplicationId();
    applicationInstanceToApplicationInstanceId =
        new ApplicationInstanceToApplicationInstanceId();
    applicationComponentToComponentId = new ApplicationComponentToComponentId();
    applicationComponentToDeployableComponent = new ApplicationComponentToDeployableComponent();
    applicationComponentToContainerType =
        new ApplicationComponentToContainerType(configuration);
    osConverter = new OsConverter();
    this.configuration = configuration;
}
 

import play.db.jpa.JPAApi; //导入依赖的package包/类
public CreateVirtualMachineJob(JPAApi jpaApi, VirtualMachine virtualMachine,
    RemoteModelService<VirtualMachine> modelService, ModelService<Tenant> tenantModelService,
    ColosseumComputeService colosseumComputeService, Tenant tenant,
    KeyPairStrategy keyPairStrategy,
    RemoteConnectionStrategy.RemoteConnectionStrategyFactory remoteConnectionFactory,
    PortProvidedService portProvidedService) {
    super(jpaApi, virtualMachine, modelService, tenantModelService, colosseumComputeService,
        tenant);

    checkNotNull(keyPairStrategy);
    checkNotNull(remoteConnectionFactory);

    this.keyPairStrategy = keyPairStrategy;
    this.remoteConnectionFactory = remoteConnectionFactory;
    this.portProvidedService = portProvidedService;
}
 

import play.db.jpa.JPAApi; //导入依赖的package包/类
@Override protected void configure() {

        bindInterceptor(Matchers.subclassesOf(Runnable.class), Matchers.annotatedWith(Loop.class),
            new LoopRunnableInterceptor());
        bindInterceptor(Matchers.subclassesOf(Runnable.class),
            Matchers.annotatedWith(Transactional.class),
            new TransactionalRunnableInterceptor(getProvider(JPAApi.class)));

        final ThreadFactory threadFactory =
            new ThreadFactoryBuilder().setNameFormat("ExecutionService-%d").build();

        bind(ExecutionService.class).toInstance(new StableScheduledThreadExecutor(
            new ScheduledThreadPoolExecutorExecutionService(new LoggingScheduledThreadPoolExecutor(
                configuration.getInt("colosseum.execution.thread", 10), threadFactory))));
        bind(ExecutionSystemInitialization.class).asEagerSingleton();

        Multibinder.newSetBinder(binder(), Runnable.class);
        Multibinder.newSetBinder(binder(), Schedulable.class);
    }
 

import play.db.jpa.JPAApi; //导入依赖的package包/类
@Inject 
public LoginController(CidadaoDAO dao, WSClient ws, FormFactory formFactory,
		Configuration configuration, JPAApi api, AuthUtils authenticator) {
	this.dao = dao;
	this.ws = ws;
	this.formFactory = formFactory;
	this.api = api;
	this.authenticator = authenticator;
	this.facebookSecret = configuration.getString(ProvedorDeLogin.FACEBOOK.getSecretProp());
	this.googleSecret = configuration.getString(ProvedorDeLogin.GOOGLE.getSecretProp());
}
 

import play.db.jpa.JPAApi; //导入依赖的package包/类
/**
   * @param jpaAPI
   */
  @Inject
  public InitialData(JPAApi jpaAPI, CidadaoDAO daoCidadao, AtualizacaoDAO daoAtualizacao, Configuration configuration) throws SQLException {
      Logger.debug("Iniciando a aplicação.");

dataDir = Paths.get(configuration.getString("diferentonas.data", DIST_DATA)).toAbsolutePath().toString();

      String adminEmail = configuration.getString(Cidadao.ADMIN_EMAIL);
if(adminEmail == null || adminEmail.trim().isEmpty()){
      	throw new RuntimeException("Atribua um valor a diferentonas.admin.email no seu arquivo de configuração!");
      }

for (ProvedorDeLogin provedorDeLogin : ProvedorDeLogin.values()) {
	String token = configuration.getString(provedorDeLogin
			.getSecretProp());
	if (token == null || token.trim().isEmpty()) {
		throw new RuntimeException(
				"Atribua um valor a "
						+ provedorDeLogin.getSecretProp()
						+ " no seu arquivo de configuração ou seus usuários não poderão se autenticar usando o "
						+ provedorDeLogin.getName());
	}
}

      populaCidadaos(jpaAPI, daoCidadao, adminEmail, configuration.getInt("diferentonas.demo.numerodecidadaos", 0));

      populaCidades(jpaAPI);
  }
 

import play.db.jpa.JPAApi; //导入依赖的package包/类
private void populaVizinhos(JPAApi jpaAPI) throws SQLException {
String dataPath = dataDir + "/vizinhos.euclidiano.csv";
Logger.info("Cidades semelhantes vêm de " + dataPath);
int count = 0;

final ResultSet vizinhosResultSet = new Csv().read(dataPath, null, "utf-8");
count = 0;
while (vizinhosResultSet.next()) {
	long originID = vizinhosResultSet.getLong(12);

	LongStream similaresIDs = LongStream
			.range(13, 23)
			.map(value -> {
				try {
					return vizinhosResultSet.getLong((int) value);
				} catch (Exception e) {
					Logger.error("Não recuperou cidade " + value + " similar a " + originID, e);
					return 0;
				}
			});

	EntityManager em = jpaAPI.em();
	Cidade o = em.find(Cidade.class, originID);
	List<Cidade> similares = similaresIDs
			.mapToObj(
					value -> em
					.find(Cidade.class, value))
					.map(obj -> (Cidade) obj)
					.collect(Collectors.toList());
	o.setSimilares(similares);
	em.persist(o);
	count++;
	if (count % 1000 == 0) {
		Logger.info("Inseri vizinhos para " + count + " cidades...");
	}
}
  }
 

import play.db.jpa.JPAApi; //导入依赖的package包/类
@After
public void limpaBancoDepoisDeTestes() {
	JPAApi jpaAPI = app.injector().instanceOf(JPAApi.class);
	CidadeDAO cidadeDAO = app.injector().instanceOf(CidadeDAO.class);
	IniciativaDAO iniciativaDAO = app.injector().instanceOf(IniciativaDAO.class);
	jpaAPI.withTransaction(() ->{
		if(cidadeDAO.find(-1L) != null){
			cidadeDAO.remove(cidadeDAO.find(-1L));
		}
		if(iniciativaDAO.find(-1L) != null){
			iniciativaDAO.remove(iniciativaDAO.find(-1L));
		}
	});
}