Spring JPA @Converter-如何使用实体自己的id作为盐来加密实体？

Question

So I have this case where the JPA entity is encrypted using it's own ID as salt.

Here is an example of doing the en/decrypt without annotation, I have to "manually" create custom get/setter to each encrypted fields.

StandardDbCipher is just my cipher class that accepts a salt during construction (which is in this case is the ID field). The password is already fixed in some other file.

@Entity
public class Applicant implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private String id;

    private String profilePic;

    private String contact;

    private String personalInfo;

    @Transient
    private StandardDbCipher cipher;

    private StandardDbCipher getCipher() {
        if (cipher == null) {
            cipher = new StandardDbCipher(id);
        }
        return cipher;
    }

    private String encrypt (String plain) {
        return getCipher().decrypt(plain);
    }

    private String decrypt (String crypt) {
        return getCipher().encrypt(crypt);
    }

    public String getProfilePic() {
        return decrypt(profilePic);
    }

    public void setProfilePic(String profilePic) {
        this.profilePic = encrypt(profilePic);
    }

    public String getContact() {
        return decrypt(contact);
    }

    public void setContact(String contact) {
        this.contact = encrypt(contact);
    }

    public String getPersonalInfo() {
        return decrypt(personalInfo);
    }

    public void setPersonalInfo(String personalInfo) {
        this.personalInfo = encrypt(personalInfo);
    }

}

I would like to simplify the code and reduce boilerplate using @Converter , but couldn't figure out how to put the ID as salt? Any ideas? Maybe other annotation?

Answer 1

If it's something that you need to do in many entities, then I think you can try Aspect Oriented Programming (the most known implementation is AspectJ). Spring also has an integration with that (I've not worked with that as I'm not using Spring). The idea is that you can have some intercepting code that would be executed before or after a call to methods of your objects (in your case getter/setter methods of your entities) and inside them you can manipulate the actual object/parameters/return values.

You can call your encrypt method before the execution of setter method and pass the encrypted value to your setter. For the decryption, you run your decrypt method after the execution of the getter method.

By doing so, your entities would remain as a simple POJO and you don't need to provide a converter for each.

. Here are some tutorial demonstrating the AOP concept:

• @AspectJ Based AOP with Spring
• Introduction to Spring AOP

Update: Another solution could be to use JPA Entity Listeners . You can do the encryption on @PrePersist and the decryption on @PostLoad callbacks in your entity or use a single listener class for all such entities. You would just need to annotate your POJOs like this:

@Entity
@EntityListeners(class=EncDecListener.class)
public class Applicant implements Serializable {

}

public class EncDecListener {
    @PreUpdate
    public void encrypt(Applicatnt a) {
        // do encryption
    }


    @PostLoad
    public void decrypt(Applicatnt a) {
        // do decryption
    }
}