Mensagens enviadas por: legionarioba

A documentação do Spring sugere o uso da anotação @Transactional nas classes concretas:

Spring recommends that you only annotate concrete classes (and methods of concrete classes)
with the @Transactional annotation, as opposed to annotating interfaces. You certainly
can place the @Transactional annotation on an interface (or an interface method), but
this works only as you would expect it to if you are using interface-based proxies. The fact
that annotations are not inherited means that if you are using class-based proxies
(proxy-target-class="true") or the weaving-based aspect (mode="aspectj"),
then the transaction settings are not recognized by the proxying and weaving infrastructure,
and the object will not be wrapped in a transactional proxy, which would be decidedly bad.

Spring Documentation - Part IV (Data Access) - 10.5 Declarative transaction management - Using @Transactional

Outra coisa, sua classe está no base-package que você definiu no elemento <context:component-scan>?

rchgonzaga wrote:-locale en_US -services "services-config.xml"

-locale en_US -services "services-config.xml" -context-root=SEUCONTEXTO

fabioebner wrote:Pessoal, estou tentando integrar o meu projeto Flex com o Spring pelo SpringIntegration, estou seguindo o exemplo desse site: http://www.springbyexample.org/examples/simple-flex-webapp.html

porem estou com alguns problemas, alguem pode me ajudar?

meu web.xml
<?xml version="1.0" encoding="UTF-8"?> <web-app id="WebApp_ID" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"> <display-name>CartorioMaps</display-name> <context-param> <param-name>flex.class.path</param-name> <param-value>/WEB-INF/flex/hotfixes,/WEB-INF/flex/jars</param-value> </context-param>  <listener> <listener-class>flex.messaging.HttpFlexSession</listener-class> </listener> <context-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/applicationContext.xml</param-value> </context-param> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener>  <servlet> <servlet-name>MessageBrokerServlet</servlet-name> <servlet-class>flex.messaging.MessageBrokerServlet</servlet-class> <init-param> <param-name>services.configuration.file</param-name> <param-value>/WEB-INF/flex/services-config.xml</param-value> </init-param> <init-param> <param-name>flex.write.path</param-name> <param-value>/WEB-INF/flex</param-value> </init-param> <load-on-startup>2</load-on-startup> </servlet> <servlet-mapping> <servlet-name>MessageBrokerServlet</servlet-name> <url-pattern>/messagebroker/*</url-pattern> </servlet-mapping> <servlet> <servlet-name>spring-flex</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <init-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/flex-servlet-context.xml</param-value> </init-param> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>spring-flex</servlet-name> <url-pattern>/spring/*</url-pattern> </servlet-mapping> <welcome-file-list> <welcome-file>index.html</welcome-file> <welcome-file>index.htm</welcome-file> <welcome-file>index.jsp</welcome-file> <welcome-file>default.html</welcome-file> <welcome-file>default.htm</welcome-file> <welcome-file>default.jsp</welcome-file> </welcome-file-list> </web-app>
meu remote-config.xml
<?xml version="1.0" encoding="UTF-8"?> <service id="remoting-service" class="flex.messaging.services.RemotingService"> <adapters> <adapter-definition id="java-object" class="flex.messaging.services.remoting.adapters.JavaAdapter" default="true"/> </adapters> <default-channels> <channel ref="person-amf"/> </default-channels> </service>

meu services-config.xml
<?xml version="1.0" encoding="UTF-8"?> <services-config> <services> <service-include file-path="remoting-config.xml" /> <default-channels> <channel ref="person-amf"/> </default-channels> </services> <channels> <channel-definition id="person-amf" class="mx.messaging.channels.AMFChannel"> <endpoint url="http://{server.name}:{server.port}/{context.root}/spring/messagebroker/amf" class="flex.messaging.endpoints.AMFEndpoint"/> </channel-definition> </channels> <logging> <target class="flex.messaging.log.ConsoleTarget" level="Error"> <properties> <prefix>[BlazeDS] </prefix> <includeDate>false</includeDate> <includeTime>false</includeTime> <includeLevel>false</includeLevel> <includeCategory>false</includeCategory> </properties> <filters> <pattern>Endpoint.*</pattern> <pattern>Service.*</pattern> <pattern>Configuration</pattern> </filters> </target> </logging> <system> <redeploy> <enabled>false</enabled> </redeploy> </system> </services-config>

meu flex-servlet-context.xml
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" xmlns:flex="http://www.springframework.org/schema/flex" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/flex http://www.springframework.org/schema/flex/spring-flex-1.0.xsd"> <context:component-scan base-package="br.com.dnasolution" /> <flex:message-broker/> </beans>

meu applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:flex="http://www.springframework.org/schema/flex" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd http://www.springframework.org/schema/flex http://www.springframework.org/schema/flex/spring-flex-1.0.xsd "> <context:annotation-config/> <context:component-scan base-package="br"/> <aop:aspectj-autoproxy/> <bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean" > <property name="dataSource"> <ref local="c3p0DataSource"/> </property> <property name="annotatedClasses"> <list> <value>br.com.dnasolution.cartoriomaps.entity.TbCartorio</value> <value>br.com.dnasolution.cartoriomaps.entity.TbNatureza</value> </list> </property> <property name="hibernateProperties"> <props> <prop key="hibernate.dialect">org.hibernate.dialect.PostgreSQLDialect</prop> <prop key="hibernate.connection.autocommit">false</prop> </props> </property> </bean> <bean id="c3p0DataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> <property name="driverClass" value="org.postgresql.Driver"/> <property name="jdbcUrl" value="jdbc:postgresql://localhost:5432/db_asdasd"/> <property name="user" value="asdasd"/> <property name="password" value="asdasdas"/> <property name="initialPoolSize" value="5"/> <property name="minPoolSize" value="5"/> <property name="maxPoolSize" value="15"/> <property name="checkoutTimeout" value="1000"/> <property name="maxStatements" value="50"/> <property name="testConnectionOnCheckin" value="true"/> <property name="idleConnectionTestPeriod" value="60"/> </bean> <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/> </bean> </beans>

no meu xmlxml eu fiz o seguinte:

<mx:RemoteObject id="cartoroi" destination="cartorioFACADE" showBusyCursor="true" fault="erro(event)" result="foi(event)"/>

tenho as funcoes public function iniciar(event:Event):void{ cartoroi.teste("Binhoca"); currentState=PRINCIPAL_STATE; } public function erro(event:FaultEvent):void{ Alert.show(event.fault.message); } public function foi(event:ResultEvent):void{ Alert.show(event.result.toString()); }

tenhoa minha classe q eu quero expor package br.com.dnasolution.cartoriomaps.facade; import org.springframework.context.annotation.Scope; import org.springframework.flex.remoting.RemotingDestination; import org.springframework.stereotype.Service; @Service("cartorioFACADE") @RemotingDestination public class CartorioFACADE { public String teste(String nome){ return nome + "foiiiiiiiiiiiiiii"; } }

e recebo o seguinte erro:

faultCode:InvokeFailed faultString:'[MessagingError message='Destination 'cartorioFACADE' either does not exist or the destination has no channels defined (and the application does not define any default channels.)']' faultDetail:'Couldn't establish a connection to 'cartorioFACADE''

alguem pode me ajudar? pelo q eu entendi ele fala q nao possui nenhum canal de comunicacao entre o flex e o java criado, mas eu declaro ali o meu "person-amf"

e nada

Você está incluindo o services-config.xml e o remote-config.xm como parâmetro de compilação da sua aplicação flex? E o context-root também está sendo setado também? Você precisa disso, pois as variáveis {server.name} e {server.port} são montadas por "si só", mas o {context.root} precisa ser passado para o compilador flex...(via linha de comando, ou usando maven, via o plugin flexmojos)

Alessandro Lazarotti wrote:

legionarioba wrote:

Alessandro Lazarotti wrote:

legionarioba wrote:
Você tem um facade, que é seu EJB, lá você anota ele (@EJB). Simples, ok...mas ai você quer injetar um dao , vai querer usar um @EJB tb? Simples, mas seria um equívoco...

Não defendendo ninguém, mas pq usar um EJB como "DAO" (suponhando que fosse necessário realmente um DAO em seu projeto) atras de uma Façade seria um equívoco? Não consigo compreender este tipo de afirmação solta fora de algum contexto. Por acaso você acha que um Stateless é mais caro para um servidor JavaEE do que um POJO seria para um microcontainer como o Spring?

Não é questão de usar EJB com Dao..Poderia ser DAO, BO, qualquer camada em sua divisão arquitetural...a afirmação apenas foi pra denotar que qualquer injeção de alguma classe colaborativa que você venha a ter no seu EJB, usando apenas EJB, você precisaria da anotação @EJB...O que questionei foi: transformar uma classe colaborativa qualquer em EJB para usar a injeção de dependência. A questão não é só o custo de um Stateless, mas o fato de deixar uma brecha para expôr uma classe colaborativa(BO, DAO, Repository o que for), e que esta não deveria ser acessível remotamente, ter por exemplo um Ejb de fachada, acessando um EJB de negócio, que acessa um EJB de acesso a dados, algo desse tipo... Este é o equívoco...
Acredito que o custo de manter o cache de uma instância num microcontainer seja menos custoso que um Stateless em um server JEE(mas não tenho benchmarking pra tal)...

Mas legionarioba], não é pq é EJB que precisa ser "remote", ele pode ser "local". Tbm não é pq vc usa EJB que você não pode utilizar qualquer framework de DI para injeção de classes utilitárias.

Só quis dizer que injeção de dependência com "EJB puro" só funciona com quem está anotado com @EJB (não entrei no mérito de ser local ou remote). Ainda sim, conceitualmente uma camada de acesso a dados não é um EJB(ainda que eu possa minimizar isso utilizando como local)... E claro, além do Spring poderia ser qualquer outro frame de DI...(mas já que o tópico é sobre Spring..

)

Meu único pensamento é: não fazer de uma classe qualquer um EJB(ainda que local), pra usar DI...

Alessandro Lazarotti wrote:

legionarioba wrote:
Você tem um facade, que é seu EJB, lá você anota ele (@EJB). Simples, ok...mas ai você quer injetar um dao , vai querer usar um @EJB tb? Simples, mas seria um equívoco...

Não defendendo ninguém, mas pq usar um EJB como "DAO" (suponhando que fosse necessário realmente um DAO em seu projeto) atras de uma Façade seria um equívoco? Não consigo compreender este tipo de afirmação solta fora de algum contexto. Por acaso você acha que um Stateless é mais caro para um servidor JavaEE do que um POJO seria para um microcontainer como o Spring?

Não é questão de usar EJB com Dao..Poderia ser DAO, BO, qualquer camada em sua divisão arquitetural...a afirmação apenas foi pra denotar que qualquer injeção de alguma classe colaborativa que você venha a ter no seu EJB, usando apenas EJB, você precisaria da anotação @EJB...O que questionei foi: transformar uma classe colaborativa qualquer em EJB para usar a injeção de dependência. A questão não é só o custo de um Stateless, mas o fato de deixar uma brecha para expôr uma classe colaborativa(BO, DAO, Repository o que for), e que esta não deveria ser acessível remotamente, ter por exemplo um Ejb de fachada, acessando um EJB de negócio, que acessa um EJB de acesso a dados, algo desse tipo... Este é o equívoco...
Acredito que o custo de manter o cache de uma instância num microcontainer seja menos custoso que um Stateless em um server JEE(mas não tenho benchmarking pra tal)...

Rodrigo.Lima wrote:Pra que usar dao?

Você não vai implementar lógica de negócio, acesso a dados, tudo na sua implementação do EJB vai?

chun wrote:
Mais simples ?
Tem coisa mais simples que um @Stateless ? um @EJB ?

Você tem um facade, que é seu EJB, lá você anota ele (@EJB). Simples, ok...mas ai você quer injetar um dao , vai querer usar um @EJB tb? Simples, mas seria um equívoco...

Em meu caso seria uma regularExpression mesmo. Eu não teria como validar que uma regular expression obter* garanta comportamento apenas de leitura , e gravar* seja transacional. Mas se eu pelo menos pudesse validar que nas classes desse pacote, tivessem apenas assinatura dos dois tipos, ao menos conseguiria cobrir os casos em que o padrão fugiria dos dois. Não quero definir um padrão assim:

transacional: gravar*
leitura : *

entendeu? Ao menos isso já me daria garantia de evitar que métodos estivessem fora de um dos dois padrões ....

Pablo,

Eu sei o que eu teria que fazer, em tese tive o mesmo pensamento dessa sua sugestão, a questão é, já existe alguma ferramenta que faça esse tipo de trabalho? Porque PMD, CheckStyle partem de definições inerentes aos mesmos, e inspecionam os fontes(seja via plugin no Eclipse, seja via Hudson, Maven). Gostaria de algo parecido, mas para o cenário que citei..

Não, os dois não se aplicam a meu caso...

O que quero é algo como nesse exemplo:

Método transacional : gravarUsuario, gravarPolitica, (gravar*)

Método leitura : obterUsuarios, obterPoliticas, obter*

Eu quero validar que meus métodos estão seguindo tais regras...

Boa tarde PessoALL,

Estou trabalhando em uma aplicação multi-modular, com uma estrutura relativamente complexa, e estou configurando o comportamento transacional através de Spring AOP. Gostaria de, no meu processo de integração contínua( e desenvolvimento no Eclipse também), fiscalizar que os nomes dos métodos utilizados em um determinado package (br.corporacao.*.services.*), sigam determinada nomenclatura, pra que eu possa garantir que o comportamento transacional irá funcionar com corretude(sem ter que esperar assertividade precisa dos desenvolvedores da equipe, e garantindo o comportamento em todos os módulos do sistema). Existe alguma ferramenta capaz de executar tal tarefa?

Olá pessoALL,

Aqui na empresa estamos num trabalho e existe um ponto bastante desafiador. Estamos desenvolvendo um produto cujo objetivo é efetuar uma comparação entre dados de duas bases(com modelos idênticos) e gerar um relatório de discrepância. Uma base, é fruto de varredura executada na rede, e a outra, é do sistema de cadastro da empresa. A idéia é que se tenha a visão de que existem equipamentos na rede que não estão cadastrados, equipamentos no cadastro que não existam mais na rede, ou mesmo diferença nos dados de configuração entre uma tabela de roteamento (que encontrou o mesmo roteador em ambas as bases) por exemplo.

A questão é que, por se tratar de um produto, a base de cadastro da empresa pode ser de bancos diferentes(oracle, sql, db2), e mais, o próprio modelo do banco pode ser bem diferente. No cenário atual, a base de cadastro da empresa é um modelo relacional, mas modelado como metamodelo(não tenho uma tabela roteador, tenho uma tabela classe, que possui um registro roteador,e a mesma analogia vale para os campos. Poderia ser um modelo puramente relacional, com uma tabela roteador, e seus respectivos campos.

Minha tarefa é criar uma espécie de engine de transformação em que o usuário possa estabelecer o de/para entre o que está na base do cliente, e a base que armazena os dados da rede. Não posso me prender ao modelo dos dois bancos, mas preciso conseguir definir posteriormente executar regras de mapeamento do tipo um "atributo la/um atributo ca", e dai conseguir fazer a leitura do valor que desejo em uma ponta, e gerar os devidos inserts na outra, de acordo com a correspondência.

Enfim, preciso gerar um schema pra que esse mapeamento seja gravado, e então eu possa escrever as regras que me dizem como recuperar e inserir valores para que eu carregue as informações da base do cliente nessa minha base com modelo idêntico a base da rede.

Já existe algo desenvolvido, ou existe algum padrão de projeto, framework ou direcionamento pra eu cumprir essa tarefa, independentemente de como serão esses dois modelos de dados??

Olá pessoALL,

Alguém de vocês já teve experiência com os dois? Estou preparando um ambiente pra utilização do Maven, pra posterior uso da Integração Contínua (com Continuum), mas ainda não consegui me decidir por qual dos dois adotar. Eu ouvi bons comentários sobre o Artifactory, mas precisava saber se algum leva alguma vantagem considerável, ou posso ser feliz com qualquer um dos dois ... hehehe

Explica melhor essa arquitetura...O processo de criação da session factory é bastante custoso, mas como o mesmo é thread-safe no caso da web você cria chamando o HibernateUtil num listener do contexto, mas no seu caso, com usuários distintos com schemas distintos, isso pode ser deveras custoso. Desculpe perguntar, mas que tipo de negócio trabalha para gerar 50 milhões de registros em uma única tabela em um mês

Tabelas criadas mensalmente? Xii tá com cara de furo, explica melhor porque você precisa disso..

Existe a classe SchemaExport, que recebe um Configuration(aquele mesmo do seu HibernateUtil). Mas isso é usado pra, por exemplo, se você quiser criar um programinha desktop, e deixar o cliente escolher qual banco quer utilizar(vais precisar claro das configs e acessos do banco). Essa situação sua não vejo muito sentido...

Notícias, artigos e o maior fórum brasileiro sobre Java