How to use custom salt for password encryption in grails spring security plugin

class User {

    transient springSecurityService

    String username
    String password
    String email
    String salt 
    boolean enabled = true
    boolean accountExpired
    boolean accountLocked
    boolean passwordExpired

    static transients = ['springSecurityService']

    static constraints = {
        username blank: false, unique: true
        password blank: false
    }

    static mapping = {
        password column: '`password`'
    }

    Set getAuthorities() {
        UserRole.findAllByUser(this).collect { it.role }
    }

    String getSalt() {
    if(this.salt == null){
        this.salt = UUID.randomUUID().toString()
    }
        this.salt
    }
    /*def beforeInsert() {
        encodePassword()
    }

    def beforeUpdate() {
        if (isDirty('password')) {
            encodePassword()
        }
    }

    protected void encodePassword() {
        password = springSecurityService?.passwordEncoder ? springSecurityService.encodePassword(password) : password
    }*/
}

import grails.plugin.springsecurity.userdetails.GrailsUser
import org.springframework.security.core.GrantedAuthority

class CustomUserDetails extends GrailsUser {
    public final String salt

     CustomUserDetails(String username, String password, boolean enabled,
                 boolean accountNonExpired, boolean credentialsNonExpired,
                 boolean accountNonLocked,
                 Collection authorities,
                 long id, String salt) {
      super(username, password, enabled, accountNonExpired,
            credentialsNonExpired, accountNonLocked, authorities, id)

      this.salt = salt
   }

   String getSalt(){
       println "Custom salt for this user is  == "+this.salt
       return null
   }
}

Step 4. Now we need to make changes in CustomUserDetailsService file we have created during spring security configuration (follow ) Instead of GrailsUser we will initialize CustomUserDetails class , which accept an extra parameter salt

 return new CustomUserDetails(user.username, user.password, user.enabled,
            !user.accountExpired, !user.passwordExpired,
            !user.accountLocked, authorities ?: NO_ROLES, user.id,
            user.salt)

grails.plugin.springsecurity.dao.reflectionSaltSourceProperty = 'salt'

import com.abhimanyu.example.auth.Role
import com.abhimanyu.example.auth.User
import com.abhimanyu.example.auth.UserRole
import grails.plugin.springsecurity.authentication.dao.NullSaltSource

class BootStrap {

    def saltSource
    def springSecurityService
    def grailsApplication
    def init = { servletContext ->
        if(Role.list().size() == 0){
                new Role(authority:"ROLE_SUPERADMIN").save()
                new Role(authority:"ROLE_ADMIN").save()

        }

        if(User.list().size() == 0){
            String customSalt = UUID.randomUUID().toString();
            String salt = saltSource instanceof NullSaltSource ? null : customSalt
            String encodedPassword = springSecurityService.encodePassword('root',salt)
            def superUser = new User( email:"[email protected]",
                                      password:encodedPassword,
                                      accountLocked: false,
                                      enabled: true,
                                      accountExpired:false,
                                      passwordExpired:false,
                                      username:"SUPERADMIN",
                                      salt:customSalt
                                    )
            superUser.save()
            superUser.errors.each{
                println it
            }
            def role = new UserRole(user:superUser,role:Role.findWhere(authority:'ROLE_SUPERADMIN')).save();
            }

    }
    def destroy = {
    }
}