I am installing Activiti 5.17.0's Activiti Explorer and would like to use a JNDI-based datasource configuration to connect to an Oracle DB. The documentation I found here: http://www.activiti.org/userguide/#jndiDatasourceConfig is very explicit about making this change but unfortunately the docs seems to be obsolete.
In particular, I found no activiti-standalone-context.xml and no activiti-context.xml at the mentioned places. I assume it got changed to activiti-custom-context.xml, but the whole content of this Spring configuration is commented out (which makes me wonder where the actual Spring config might come from).
I tried to configure the datasource in this file anyway using this approach:
<jee:jndi-lookup id="dataSource"
jndi-name="jdbc/activiti-ds"
expected-type="javax.sql.DataSource" />
and this approach as well:
<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="proxyInterface" value="javax.sql.DataSource"/>
<property name="jndiName"><value>jdbc/activiti-ds</value></property>
</bean>
but both my attempts ended up in the same ClassCastException, claiming that the generated Proxy class is not an instance of javax.sql.DataSource:
java.lang.ClassCastException: org.springframework.jndi.JndiObjectFactoryBean$$EnhancerBySpringCGLIB$$69ba43af cannot be cast to javax.sql.DataSource
at org.activiti.explorer.conf.ActivitiEngineConfiguration$$EnhancerBySpringCGLIB$$5db7207e.dataSource(<generated>)
at org.activiti.explorer.conf.ActivitiEngineConfiguration.processEngineConfiguration(ActivitiEngineConfiguration.java:91)
Any hints how to accomplish to this task? Maybe a pointer to an up-to-date documentation?
For further reference, I solved the problem by editing the Spring JavaConfig in ActivitiEngineConfiguration.java and replacing the dataSource bean creation there with the following code:
#Bean
public DataSource dataSource() {
final JndiDataSourceLookup dsLookup = new JndiDataSourceLookup();
dsLookup.setResourceRef(true);
DataSource dataSource = dsLookup.getDataSource("jdbc/activiti-ds");
return dataSource;
}
After recompiling the module and deploying, it seems to work flawlessly.
Thanks a lot to Greg Harley above whose questions and commented helped to solve the problem!
The Activiti users guide includes updated instructions for how to configure a JDBC datasource here: http://www.activiti.org/userguide/#jndiDatasourceConfig
You will need to configure a datasource bean in the ActivitiEngineConfiguration class of your web application and update the following line of code to reference your new datasource:
processEngineConfiguration.setDataSource(dataSource());
If you want to continue to use the Spring XML configuration, you can still define your custom beans in the activiti-custom-context.xml.
Related
We are upgrading from Spring 3.2.4 to Spring 4.3.8 in which singleton="false" is no longer supported. What is the way to set singleton 'false' in Spring 4.3.8?
If singeton="false" then does it means that spring bean scope has become "Prototype"?
You can use #Scope for specifying prototype bean.
Example:
#Bean #Scope("prototype")
public Person personPrototype() {
return new Person();
}
for further reading follow link
As far as I remember, singleton=false was kept for some compatibility reasons, also indicated in some older docs, eg 3.0.0.M3:
<bean id="accountService" class="com.foo.DefaultAccountService"/>
the following is equivalent, though redundant (singleton scope is the default); using spring-beans-2.0.dtd
<bean id="accountService"> class="com.foo.DefaultAccountService" scope="singleton"/>
the following is equivalent and preserved for backward compatibility in spring-beans.dtd
<bean id="accountService"> class="com.foo.DefaultAccountService" singleton="true"/>
Anyway, the default spring scope is singleton, so even when unspecified, but can be changed to prototype (or whatever you need) with:
XML: scope="prototype"
Java DSL: #Scope("prototype") or #Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
Correct, scope="prototype" is the direct equivalent of singleton="false".
The equivalent of singleton="false" is scope="prototype".
another alternative is to use the annotation #Scope("prototype")
The equivalent of singleton="true" would be to eliminate this attribute in the spring config, since scope="singleton" would be the default.
I have modified my original question slightly to better reflect my question. I have a non-Spring Boot application that I would like to have working with the Spring Cloud Config Server. I have searched around online and tried many things but it seems like the crux of my issue is that the server only works within a Spring Boot context. Although ActiveMQ is a Spring application already, it seems non-trivial to convert it to be a Spring Boot one.
I would like to have an ActiveMQ Broker that is configured from the Spring Cloud Config. My local settings within the application.properties should be replaced by those that come from the server. This works in other servers I work on, now I need it to work for my Broker Filter plugins.
I added the following to activemq.xml:
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<list>
<value>classpath:application.properties</value>
<value>file:${activemq.conf}/credentials.properties</value>
</list>
</property>
</bean>
NOTE: Several base packages omitted here but are similar to:
<context:component-scan base-package="org.springframework.cloud.bootstrap"/>
<!-- enables annotation based configuration -->
<context:annotation-config />
After doing so I was able to get various #Value annotations to work with settings coming from my application.properties but the whole Spring Cloud Config Server thing seems to not replace my local application.properties file settings. Other Spring Boot application I work on do so I know the server is fine.
I have added the following jars to the apache-activemq-5.12.0\lib\extra directory:
spring-aop-4.1.8.RELEASE.jar
spring-beans-4.1.8.RELEASE.jar
spring-boot-1.2.7.RELEASE.jar
spring-boot-actuator-1.2.7.RELEASE.jar
spring-boot-autoconfigure-1.2.7.RELEASE.jar
spring-boot-starter-1.2.7.RELEASE.jar
spring-boot-starter-actuator-1.2.7.RELEASE.jar
spring-boot-starter-data-mongodb-1.2.7.RELEASE.jar
spring-boot-starter-logging-1.2.7.RELEASE.jar
spring-cloud-commons-1.0.1.RELEASE.jar
spring-cloud-config-client-1.0.1.RELEASE.jar
spring-cloud-context-1.0.1.RELEASE.jar
spring-cloud-starter-1.0.1.RELEASE.jar
spring-cloud-starter-config-1.0.1.RELEASE.jar
spring-context-4.1.8.RELEASE.jar
spring-context-support-4.1.8.RELEASE.jar
spring-core-4.1.8.RELEASE.jar
spring-data-commons-1.11.0.RELEASE.jar
spring-data-mongodb-1.8.0.RELEASE.jar
spring-expression-4.1.8.RELEASE.jar
spring-jms-4.1.8.RELEASE.jar
spring-security-crypto-3.2.8.RELEASE.jar
spring-test-4.1.8.RELEASE.jar
spring-tx-4.1.8.RELEASE.jar
spring-web-4.1.8.RELEASE.jar
refreshendpoint is not necessarily initialized when the constructor is called. You need to add a method annotation with #PostConstruct (or implement InitializingBean and implement afterPropertiesSet method) in which you'll perform refreshendpoint.refresh(); , e.g:
#PostConstruct
void init() {
refreshendpoint.refresh();
}
I been trying to find a example of how to do multiple file upload in Spring MVC without using XML only Java Config. So far have found nothing and a lot of people that just either want hits to sites or don't know what java configuration v xml configuration is.
I don't use Spring Boot and don't want to as I want to learn this framework no matter how difficult.
Even advice on how to convert the following line to java config would be appreciated:
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<property name="maxUploadSize" value="1000000" />
</bean>
Please do advise also what JARs i would need for the above multipartResolver.
Thanks a bunch gang
That line translates to
#Bean
public MultipartResolver multipartResolver() {
org.springframework.web.multipart.commons.CommonsMultipartResolver multipartResolver = new org.springframework.web.multipart.commons.CommonsMultipartResolver();
multipartResolver.setMaxUploadSize(1000000);
return multipartResolver;
}
Within a #Configuration class which you'd load in your Servlet context.
You need commons-fileupload library for this to work.
How do I properly configure flyway when integrating with Spring? I see there is a configure method that takes properties, but from the spring XML it would take a setter method to provide a way to inject a Properties instance.
I could write my own Pojo to delegate the configuration to the flyway instance, but it somehow feels like I have missed something.
Here is my configuration:
<bean
id="flyway"
class="com.googlecode.flyway.core.Flyway"
init-method="migrate"
lazy-init="false"
depends-on="dataSource"
>
<property name="dataSource" ref="dataSource" />
<property name="locations" value="classpath:/META-INF/migrations" />
</bean>
I would like to provide a dedicated property file for the migration configuration as documented here:
https://github.com/flyway/flyway/blob/master/flyway-commandline/src/main/assembly/flyway.properties
From the javadoc I see that I can set most of the properties. I could work with spring ${} property replacements and loading the property file with the built in mechs, but this would make those properties available to all beans, and I would add each one I need.
My wrapper would provide a setter so I could add the following to my spring xml config:
<property name="configLocations" value="classpath:/META-INF/flyway.properties" />
Any thoughts appreciated.
Spring's MethodInvokingFactoryBean should do what you want.
Alternatively, you can create a migration based on JdbcTemplate using Flyway's SpringJdbcMigration. The following example is copied from the Flyway documentation:
import com.googlecode.flyway.core.api.migration.spring.SpringJdbcMigration;
import org.springframework.jdbc.core.JdbcTemplate;
public class V1_2__Another_user implements SpringJdbcMigration {
#Override
public void migrate(JdbcTemplate jdbcTemplate) throws Exception {
jdbcTemplate.execute("INSERT INTO test_user (name) VALUES ('Obelix')");
}
}
You should use spring annotation and wrap Flyway class, and do whatever you want. For instance, configuring flyway properties. This blog post may give you an example how to do http://esofthead.com/migrate-database-highly-change-environment-multiple-versions-management/
I understand the similar question have been asked before here, but I couldn't find the solution to my problem. Basically, I am trying to use JPA through Hibernate in Spring, but the data is not being persisted for some reason.Turning on debug on spring transaction reveals nothing - EntityManager open and closed, but nothing shows up as far as transaction manager concerns ... I am sure I miss something big, any help is appreciated! see the following for more details.
TIA
Oliver
The basic layout is as follows: class FooDaoJPA’s save function calls out entityManager.persist(object) to persist the object.
class FooServiceImpl implements the service interface by:
#Transactional(rollbackFor = DataAccessException.class,
readOnly = false, timeout = 30,
propagation = Propagation.SUPPORTS,
isolation = Isolation.DEFAULT)
public void saveFoo(Foo foo) throws DataAccessException {
fooDao.save(foo);
}
Noted that fooDao is injected by Spring IoC
Finally controller is injected a FooService and call saveFoo() to persist data.
JPA configuration
<!-- JPA Entity Manager Factory -->
<bean id="entityManagerFactory"
class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"
p:dataSource-ref="feDataSource"/>
<!-- Transaction Config -->
<bean id="transactionManager"
class="org.springframework.orm.jpa.JpaTransactionManager"
p:entityManagerFactory-ref="entityManagerFactory"/>
<tx:annotation-driven mode="aspectj"
transaction-manager="transactionManager"/>
Note the mode="aspectj" in your configuration. It requires additional configuration and usually you shouldn't use it unless you understand what does it mean and why do you need it. See 10.5.6 Using #Transactional.
The first thing that looks like a potential issue is your setting for propagation. Here is documentation showing the values you can specify:
http://static.springsource.org/spring/docs/3.0.x/javadoc-api/org/springframework/transaction/annotation/Propagation.html
Note that you've specified SUPPORTS which "Support a current transaction, execute non-transactionally if none exists". You probably want REQUIRED, which is the default, and will either use an existing transaction or create one if one does not currently exist.
In my case:
Using JPA with Spring MVC - all of my tests and code ran fine without error - symptom was that commits would simply not save to the database no matter what I tried.
I had to add
to my applicationContext.xml and cglib-nodep-2.1_3.jar aopalliance-1.0.jar
Definitely the fix in my case. Without annotation-driven Spring will not scan for the #Transactional annotation