Himai Minh

Hi, Sam,
Can you try to annotate @EnableJpaRespositories(basePackages="sam.springboot.dao") in the CourseAPIdatabaseApp ?
This way, the repository can be enabled.

Hello,
I would like to thank John Thompson, Dominik Cebula, Jesus and David Mayer for their great tutorials on Spring Framework 5.
This Spring forum and Spring Community forum are also helpful.
The books I highly recommends are Getting Started with Spring Framework 5 (4th edition), Spring In Action (4th and 5th).
Spring and Spring boot documents are must read.

Good luck to those who are taking the exam in the future.

Hi, Peter,
If the Dynamic JDK proxy is used, only public method can be proxied since we can only define public method in an interface.
And protected methods of the target object (the bean) cannot be called as this bean is called through its interface.

But if CGLib proxy is used, public and protected methods can be proxied.

Hi, in Getting Started with Spring Framework 5  4th edition , it says Spring AOP  only advices public joint point.
But as I tried , Spring AOP can advice protected or package friendly joint point like this:

@Before("execution(protected *  com..*(..))")
public void callBefore(){...}


Can anyone confirm me that Spring AOP can advice any joint point with any visibility except private?

Hi,  Wacc,
I got the same error when I signed up for this exam.
Did the bank call you or email you to confirm the payment?
If not, try to use debit card.

Hi , Geff Chang,
For Dominik's tutorial, there are only 3 modules out of 8 modules are available. I heard Dominik is still working on the 4th module.
During the meantime, you may consider to take John Thompson's Spring Core / Spring boot for the preparation.
Or, you can purchase practice exams written by David Mayer.

Hi, Stephan. Thanks for your suggestion.
I posted our discussion in the Spring community here : https://github.com/spring-projects/spring-framework/issues/23538

Hi, Stephan. Thanks for  your help. With my curiosity, I did this:
public class BankApp { private static Logger logger = LogManager.getLogger(BankApp.class); public static void main(String args[]) throws Exception { AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(); context.register(DatabaseConfig.class); context.register(DaosConfig.class); context.register(ServicesConfig.class); ... context.refresh();                //Even though it is not a good practice to get a bean based on the concrete class, I still want to try this. BankAccountServiceImpl bankAccountService = context.getBean(BankAccountServiceImpl.class); BankAccountDetails bankAccountDetails = new BankAccountDetails(); bankAccountDetails.setBalanceAmount(1000); bankAccountDetails.setLastTransactionTimestamp(new Date()); int bankAccountId = bankAccountService.createBankAccount(bankAccountDetails); ...

@Configuration public class ServicesConfig { @Bean        //It is better to return the interface instead of the class, but I still want to try. public BankAccountServiceImpl bankAccountService(BankAccountDao bankAccountDao) { BankAccountServiceImpl bankAccountServiceImpl = new BankAccountServiceImpl(); bankAccountServiceImpl.setBankAccountDao(bankAccountDao); return bankAccountServiceImpl; }

@Transactional public interface BankAccountService { int createBankAccount(BankAccountDetails bankAccountDetails); }
public class BankAccountServiceImpl implements BankAccountService {           .... @Override public int createBankAccount(BankAccountDetails bankAccountDetails) { System.out.println(" in create bank account, current trans status:" + TransactionInterceptor.currentTransactionStatus()); return bankAccountDao.createBankAccount(bankAccountDetails); } }
Configuration @PropertySource("classpath:/META-INF/database.properties") //Use CGLIB proxy instead of  JDK dynamic proxy @EnableTransactionManagement(proxyTargetClass = true) public class DatabaseConfig { @Autowired private Environment env; @Bean(destroyMethod = "close") public DataSource dataSource() {  ... }

I expect an error as the doc says @Transactional annotation is not supposed to be inherited from the interface (BankAccountService).
But my output is still fine to my surprise.
in create bank account, current trans status:org.springframework.transaction.support.DefaultTransactionStatus@628b819d

Hi, Stephan,
In the AppConfig, I set proxyTargetClass=true. So, that means a CGLIB  class based proxy is created by extending the BankAccountServiceImpl.
So, Spring only "looks" at the class, not the BankAccountService interface when Spring uses AOP to create the transaction.
And the class should not inherit the @Transaction and it should throw an IllegalStateException. But it does not.
Correct me if I am wrong.

Hi, Stephan,
In the ServiceConfig.java, I change the return type from BankAccountService to BankAccountServiceImpl like this:
@Configuration public class ServicesConfig { @Bean public BankAccountServiceImpl bankAccountService(BankAccountDao bankAccountDao) { BankAccountServiceImpl bankAccountServiceImpl = new BankAccountServiceImpl(); bankAccountServiceImpl.setBankAccountDao(bankAccountDao); return bankAccountServiceImpl; } ...}
It still works fine to my surprise.
Output:

in create bank account, current trans status:org.springframework.transaction.support.DefaultTransactionStatus@628b819d

I guess the Spring container implementation does not follow what the specification said :

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 Java annotations are not inherited from interfaces 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.

Hi, I modified the ch 8 example of Getting Started With Spring Framework 4th.
I force to use class-based proxy for BankAccountServiceImpl. I expect this proxy won't inherit the @Transactional from BankAccountService.
But my demo at https://github.com/aCodeRancher/4thEdition/tree/myTrans/chapter%208/ch08-javaconfig-hibernate/src/main/java/sample/spring/chapter08/bankapp/service
shows me that the proxy of BankAccountServiceImpl does inherit the @Transactional.

The relevant code is :
import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.EnableAspectJAutoProxy; @Configuration //Force to use class based proxy @EnableTransactionManagement(proxyTargetClass = true ) public class AppConfig { }

@Configuration public class ServicesConfig { @Bean public BankAccountService bankAccountService(BankAccountDao bankAccountDao) { BankAccountServiceImpl bankAccountServiceImpl = new BankAccountServiceImpl(); bankAccountServiceImpl.setBankAccountDao(bankAccountDao); return bankAccountServiceImpl; } ... }
import sample.spring.chapter08.bankapp.domain.BankAccountDetails; import org.springframework.transaction.annotation.Transactional; @Transactional public interface BankAccountService { int createBankAccount(BankAccountDetails bankAccountDetails); }
//This class is proxied when @Transactional is in progress. import org.springframework.transaction.interceptor.TransactionInterceptor; import sample.spring.chapter08.bankapp.dao.BankAccountDao; import sample.spring.chapter08.bankapp.domain.BankAccountDetails; import org.springframework.aop.framework.AopContext; public class BankAccountServiceImpl implements BankAccountService { private BankAccountDao bankAccountDao; public void setBankAccountDao(BankAccountDao bankAccountDao) { this.bankAccountDao = bankAccountDao; } @Override public int createBankAccount(BankAccountDetails bankAccountDetails) { System.out.println(" in create bank account, current trans status:" + TransactionInterceptor.currentTransactionStatus()); System.out.println( "current proxy: " + AopContext.currentProxy()); return bankAccountDao.createBankAccount(bankAccountDetails); } }

public class BankApp { private static Logger logger = LogManager.getLogger(BankApp.class); public static void main(String args[]) throws Exception { AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(); context.register(DatabaseConfig.class); context.register(DaosConfig.class); context.register(ServicesConfig.class); context.register(AppConfig.class); context.refresh();               BankAccountService bankAccountService = context.getBean(BankAccountService.class); BankAccountDetails bankAccountDetails = new BankAccountDetails(); bankAccountDetails.setBalanceAmount(1000); bankAccountDetails.setLastTransactionTimestamp(new Date());               //This BankAccountService is referring to the proxy of BankAccountServiceImpl int bankAccountId = bankAccountService.createBankAccount(bankAccountDetails);    …. }
The output should have an exception at TransactionInterceptor.currentTransactionStatus(). I expect the proxy won't inherit the Transaction. But to my surprise, it works. What do you think?

in create bank account, current trans status:org.springframework.transaction.support.DefaultTransactionStatus@5099c59b
current proxy: sample.spring.chapter08.bankapp.service.BankAccountServiceImpl@4c0e426a

Reference:
http://kim.saabye-pedersen.org/2013/05/spring-annotation-on-interface-or-class.html

Hi, in Spring doc

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 Java annotations are not inherited from interfaces 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.

It mentions "Java annotation are not inherited from interfaces".
But @Transactional API is meta-annotated by @Inherited. It can be inherited by children classes.
If that is the case, "Java annotation are not inherited from interfaces.... then the transaction settings are not recognized by the proxy" is not true for @Transactional.
Do you think this Spring doc needs to be updated?

I would like to ask you for opinion before I ask the Spring community.

I would recommend the Spring Community to update this part of the document.
But don't know any one from the community.

In this section, we have this :

The required attribute of @Autowired is recommended over the @Required annotation on setter methods.
The required attribute indicates that the property is not required for autowiring purposes. The property is ignored if it cannot be autowired.
...

I think it should be "required=false attribute indicates that the property is not required for autowiring purpose.

Hi,
I found you a simple example of replace web.xml by a Java class. The class extends AbstractAnnotationConfigDispatcherServletInitializer. In this class, you can specify the servlet config and root config.
https://www.mkyong.com/spring-mvc/gradle-spring-4-mvc-hello-world-example-annotation/

Another example is here:
https://www.boraji.com/spring-4-mvc-hello-world-example