Craig Andrews

Log4jdbc Spring Boot Starter

March 27th, 2017 Craig Andrews No comments

Logging SQL as it’s executed is a fairly common desire when developing applications. Perhaps an ORM (such as Hibernate) is being used, and you want to see the actual SQL being executed. Or maybe you’re tracking down a performance problem and need to know if it’s in the application or the database, so step #1 is finding out what query is executing and for how long.

Solving this problem once and for all (at least for Spring Boot applications), I created Log4jdbc Spring Boot Starter. It’s a very simple yet powerful way to log SQL queries (and more, such as timing information). And unlike other solution, the queries logged are ready to run – the ‘?’ parameters are replaced with their values. This means you can copy and paste the query from the log and run them unmodified in the SQL query tool of your choice, saving a lot of time.

For background, my motivation for this work is a result of a Spring Boot / Hibernate application I have in progress. I started by using spring.jpa.properties.hibernate.show_sql=true but that only logs queries with ‘?’ place holders. To log the values, add spring.jpa.properties.hibernate.type=trace. At least now I had the query and the values for it, but to run it in my query tool (I need to EXPLAIN the query), I had to replace each ‘?’ with the value – and I had over 20 place holders. That got old fast.

There are other approaches to log queries, such as the one described in Display SQL to Console in Spring JdbcTemplate. I’m not a fan of this approach because it only works for queries made through JdbcTemplate (so Hibernate queries aren’t logged, for example) and it’s an awfully lot of code to include and therefore have to maintain in each project.

I discovered Log4jdbc but it’s a bit of a pain to setup in a Spring Boot application because it:

doesn’t use the Spring Environment (application.properties)
needs setup to wrap the DataSource’s in the Log4jdbc DataSourceSpy

Wanting to solve this problem precisely once and never again, I created Log4jdbc Spring Boot Starter.

To use it, just add to your project:

```
<dependency>
```
```
  <groupId>com.integralblue</groupId>
```

  <artifactId>log4jdbc-spring-boot-starter</artifactId>

  <version>[INSERT VERSION HERE]</version>

```
</dependency>
```

Then turn on the logging levels as desired in application.properties, for example:

logging.level.jdbc.sqlonly=DEBUG

When no logging is configured (all loggers are set to fatal or off), log4jdbc returns the original Connection.

See the Log4jdbc Spring Boot Starter project page for more information.

Categories: Uncategorized Tags:

Working around HHH-9663: Orphan removal does not work for OneToOne relations

March 23rd, 2017 Craig Andrews No comments

HHH-9663 means that orphan removal doesn’t work for OneToOne relationships. For example, given File and FileContent as below (taken from the bug report):

```
package pl.comit.orm.model;
```
```
 
```
```
import javax.persistence.Entity;
```
```
import javax.persistence.FetchType;
```
```
import javax.persistence.Id;
```
```
import javax.persistence.OneToOne;
```
```
 
```
```
@Entity
```
```
public class File {
```
```
 
```
```
	private int id;
```
```
 
```
```
	private FileContent content;
```
```
 
```
```
	@Id
```
```
	public int getId() {
```
```
		return id;
```
```
	}
```
```
 
```
```
	public void setId(int id) {
```
```
		this.id = id;
```
```
	}
```
```
 
```

	@OneToOne(fetch = FetchType.LAZY, orphanRemoval = true)

```
	public FileContent getContent() {
```
```
		return content;
```
```
	}
```
```
 
```

	public void setContent(FileContent content) {

```
		this.content = content;
```
```
	}
```
```
}
```

```
package pl.comit.orm.model;
```
```
 
```
```
import javax.persistence.Entity;
```
```
import javax.persistence.Id;
```
```
 
```
```
@Entity
```
```
public class FileContent {
```
```
 
```
```
	private int id;
```
```
 
```
```
	@Id
```
```
	public int getId() {
```
```
		return id;
```
```
	}
```
```
 
```
```
	public void setId(int id) {
```
```
		this.id = id;
```
```
	}
```
```
}
```

```
package pl.comit.orm.dao;
```
```
 
```
```
import javax.persistence.EntityManager;
```

import javax.persistence.PersistenceContext;

```
 
```

import org.springframework.stereotype.Repository;

import org.springframework.transaction.annotation.Transactional;

```
 
```
```
import pl.comit.orm.model.File;
```
```
import pl.comit.orm.model.FileContent;
```
```
 
```
```
@Repository
```
```
public class Dao {
```
```
 
```
```
	@PersistenceContext
```
```
	private EntityManager entityManager;
```
```
 
```
```
	@Transactional
```

	public void assureCreatedTaskAndNote(int fileId, int contentId) {

		FileContent content = entityManager.find(FileContent.class, contentId);

```
		if (content == null) {
```
```
			content = new FileContent();
```
```
			content.setId(contentId);
```
```
			entityManager.persist(content);
```
```
		}
```
```
 
```

		File file = entityManager.find(File.class, fileId);

```
		if (file == null) {
```
```
			file = new File();
```
```
			file.setId(fileId);
```
```
			entityManager.persist(file);
```
```
		}
```
```
		file.setContent(content);
```
```
	}
```
```
 
```
```
	@Transactional
```

	public void removeContent(int fileId) {

		File file = entityManager.find(File.class, fileId);

```
		file.setContent(null);
```
```
	}
```
```
 
```

	public FileContent find(int contentId) {

		return entityManager.find(FileContent.class, contentId);

```
	}
```
```
}
```

Running this as the main class will result in an exception:

```
package pl.comit.orm;
```
```
 
```

import org.springframework.context.support.ClassPathXmlApplicationContext;

```
 
```
```
import pl.comit.orm.dao.Dao;
```
```
import pl.comit.orm.model.FileContent;
```
```
 
```
```
public final class Application {
```
```
 
```

	private static final String CFG_FILE = "applicationContext.xml";

```
 
```

	public static void main(String[] args) {

		test(new ClassPathXmlApplicationContext(CFG_FILE).getBean(Dao.class));

```
	}
```
```
 
```
```
	public static void test(Dao dao) {
```
```
		dao.assureCreatedTaskAndNote(1, 2);
```
```
		dao.removeContent(1);
```
```
		FileContent content = dao.find(2);
```
```
		if (content != null) {
```

			System.err.println("Content found: " + content);

```
		}
```
```
	}
```
```
}
```

A workaround is to manually remove and detach the old referent, and then persist the new referent. Here’s an updated File.java:

```
package pl.comit.orm.model;
```
```
 
```

import org.springframework.stereotype.Component;

```
 
```
```
import javax.annotation.PostConstruct;
```
```
import javax.annotation.PreDestroy;
```
```
import javax.persistence.Entity;
```
```
import javax.persistence.FetchType;
```
```
import javax.persistence.Id;
```
```
import javax.persistence.OneToOne;
```

import javax.persistence.PersistenceContext;

```
 
```
```
@Entity
```
```
public class File {
```
```
 
```
```
	private int id;
```
```
 
```
```
	private FileContent content;
```
```
 
```
```
	@Id
```
```
	public int getId() {
```
```
		return id;
```
```
	}
```
```
 
```
```
	public void setId(int id) {
```
```
		this.id = id;
```
```
	}
```
```
 
```

	@OneToOne(fetch = FetchType.LAZY, orphanRemoval = true)

```
	public FileContent getContent() {
```
```
		return content;
```
```
	}
```
```
 
```

	public void setContent(FileContent content) {

```
		if(this.content != content){
```
```
			final oldContent = this.content;
```
```
			this.content = content;
```
```
			if(oldContent!=null){
```

				// Hibernate won't remove the oldContent for us, so do it manually; workaround HHH-9663

				WorkaroundHHH9663.entityManager.remove(oldContent);

				WorkaroundHHH9663.entityManager.detach(oldContent);

```
			}
```
```
		}
```
```
	}
```
```
 
```

	// WORKAROUND https://hibernate.atlassian.net/browse/HHH-9663 "Orphan removal does not work for OneToOne relations"

```
	@Component
```

	public static class WorkaroundHHH9663 {

```
		@PersistenceContext
```

		private EntityManager injectedEntityManager;

```
 
```

		private static EntityManager entityManager;

```
 
```
```
		@PostConstruct
```
```
		public void postConstruct(){
```

			entityManager = injectedEntityManager;

```
		}
```
```
 
```
```
		@PreDestroy
```
```
		public void preDestroy(){
```
```
			this.entityManager = null; // NOPMD
```
```
		}
```
```
	}
```
```
	// END WORKAROUND
```
```
}
```

Note that no Dao changes were made, so if, for example, Spring Data was used instead of such a Dao, you wouldn’t have to modify anything else. And you can just remove this workaround code easily when a version of Hibernate because available with HHH-9963 fixed.
Finally, yes, this approach does exhibit a bit of code smell (the use of the static variable in this way and the entity having a container managed component aren’t exactly best practices), but, it’s a workaround – hopefully just a temporary one.

Categories: Uncategorized Tags:

Spring Boot, HTTPS required, and Elastic Beanstalk health checks

March 9th, 2017 Craig Andrews 2 comments

Spring Boot can be very easily configured to require HTTPS for all requests. In application.properties, simply set

security.require-ssl=true

And that works great – until you’re running the Spring Boot application on AWS Elastic Beanstalk with both HTTP and HTTPS listeners:

In that case, Elastic Beanstalk’s health check is always done over HTTP. The configuration page even says as much (there is no option to change it to be over HTTPS):

Since Spring Boot will redirect all non-secure HTTP requests to HTTPS, the health check will see an HTTP 302 redirect and therefore fail.

To workaround this issue (and in my opinion, AWS shortcoming), Spring Boot needs to be configured to allow insecure requests to the health check URL. To do so, we’ll define a new URL (/aws-health) that proxies Actuator’s health URL but responds over http and https.

In your security configuration class (named WebSecurityConfiguration below as an example) which extends WebSecurityConfigurerAdapter, add the following to the existing implementation of configure(HttpSecurity) (or create that method if it doesn’t already exist):

import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

```
 
```

import org.springframework.security.config.annotation.web.builders.HttpSecurity;

import org.springframework.security.web.access.channel.ChannelDecisionManagerImpl;

```
 
```

public class WebSecurityConfiguration extends WebSecurityConfigurerAdapter {

```
  @Override
```

  protected void configure(final HttpSecurity http) throws Exception {

    // Elastic Beanstalk health checks only happen over HTTP, so as a workaround

    // create a new URL (/aws-health) that forwards to the Actuator health check, see InsecureHealthController

    // That URL is set to respond over any channel (not just secure, aka https, ones)

    // see https://candrews.integralblue.com/2017/03/spring-boot-https-required-and-elastic-beanstalk-health-checks/

```
    http.requiresChannel()
```

      .antMatchers("/aws-health").requires(ChannelDecisionManagerImpl.ANY_CHANNEL)

```
      .anyRequest().requiresSecure();
```
```
  }
```
```
}
```

Now create the controller:

```
import java.io.IOException;
```
```
 
```
```
import javax.servlet.ServletException;
```

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletRequestWrapper;

import javax.servlet.http.HttpServletResponse;

```
 
```

import org.springframework.boot.actuate.autoconfigure.ManagementServerProperties;

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.util.UriComponentsBuilder;

```
 
```
```
/**
```

 * Elastic Beanstalk health checks only happen over HTTP, so as a workaround

 * create a new URL (/aws-health) that forwards to the Actuator health check

 * That URL is set to respond over any channel (not just secure, aka https, ones) in {@link WebSecurityConfiguration}

```
 * 
```

 * @see https://candrews.integralblue.com/2017/03/spring-boot-https-required-and-elastic-beanstalk-health-checks/

```
 */
```
```
public class InsecureHealthController {
```

  private final ManagementServerProperties management;

```
 
```

  public InsecureHealthController(ManagementServerProperties management) {

```
    this.management = management;
```
```
  }
```
```
 
```

  @RequestMapping(value="/health", method=RequestMethod.GET)

  public void health(final HttpServletRequest request, final HttpServletResponse response) throws ServletException, IOException{

    final String healthUrl = UriComponentsBuilder.fromPath(management.getContextPath()).path("/aws-health").toUriString();

    final HttpServletRequestWrapper requestWrapper = new HttpServletRequestWrapper(request){

```
      @Override
```
```
        public boolean isSecure() {
```
```
          return true;
```
```
        }
```
```
      };
```

      request.getRequestDispatcher(healthUrl).forward(requestWrapper, response);

```
    }
```
```
}
```

Categories: Uncategorized Tags:

Archive

Log4jdbc Spring Boot Starter

Working around HHH-9663: Orphan removal does not work for OneToOne relations

Spring Boot, HTTPS required, and Elastic Beanstalk health checks

Pages

Archives

Meta

March 2017
M	T	W	T	F	S	S
« Feb				Nov »
		1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30	31