Questions[spring]

I know that it is possible to name them Foreing Keysand also manually define the constraints, but isn't there a way to define a naming policy for each type of constraint and thus avoid the random identifiers that Spring generates by default?

eg for a constraint of typeUNIQUE, Spring generates the following name:UK_ob8kqyqqgmefl0aco34akdtpebut I don't know if it is possible to somehow define the following pattern:AK_TABLE_ATTRIBUTEso that Spring uses it every time it generates that type of constraint.

The foregoing more than anything to standardize the restrictions and facilitate their maintenance.

I am trying to configure a spring boot web application to use basic http security which will be used for web pages, and additionally I need to implement OAuth2 security for an android application to connect.

The problem I have is that OAuth security is overriding basic http security. Searching in google I found that it is due to the execution order of the security filters, so the ResourceServer had to be annotated with @Order(3) and the WebSecurityConfigurerAdapter with @Order(1) so that basic security would be applied first. . However I find that the basic http logs in fine, but when it tries to authenticate the user roles, it doesn't take them. The OAuth Authorization server does work and generates the token, but when it tries to access the protected resources, it either does not take the roles assigned to the user or simply does not protect the resources.

It is as if by mixing both systems, one overwrites the other.

What would be the correct way to integrate both functions (basic http and OAuth) in the same spring boot application? I read something about http.antMatchers but I can't figure it out.

WebSecurityConfig.class

@Configuration
@EnableResourceServer
@Order(1)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    private Logger log = LoggerFactory.getLogger(SecurityConfig.class);

    @Override
    protected void configure(HttpSecurity http) throws Exception {

        log.info("Configurando http security web");

        http.httpBasic();

        // Indica los recursos a proteger
        http.authorizeRequests()
                .antMatchers("/").permitAll()
                .antMatchers("/home", "/about").permitAll()
                .antMatchers("/user/**").authenticated()
                .antMatchers("/admin/**").hasRole("ADMIN")
                .antMatchers("/cuenta/**").access("hasAnyRole('USER','ADMIN')");

        // Administra la sesion
        /*http.sessionManagement()
                .invalidSessionUrl("/invalidSession.html")
                .sessionCreationPolicy(SessionCreationPolicy.IF_REQUIRED);*/

        // Configura el login
        http.formLogin()
                .successHandler(savedRequestAwareAuthenticationSuccessHandler())
                .loginPage("/login").permitAll()
                    .failureUrl("/login?error")
                .loginProcessingUrl("/auth/login_check")
                .usernameParameter("username")
                .passwordParameter("password");

        // Configura el logout
        /*http.logout()
                .permitAll()
                .logoutSuccessUrl("/login?logout");*/

        // Configura la opcion recuerdame de la sesion
        http.rememberMe()
                .tokenRepository(persistentTokenRepository())
                .tokenValiditySeconds(60); //1209600

        //super.configure(http);
    }



    @Autowired
    private DataSource dataSource;

    @Autowired
    private CustomUserDetailsService customUserDetailsService;

    @Bean
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    @Bean
    public static PasswordEncoder passwordEncoder() {
        //return (NoOpPasswordEncoder) NoOpPasswordEncoder.getInstance();
        return new BCryptPasswordEncoder();
    }

    @Bean
    public DaoAuthenticationProvider authProvider() {
        DaoAuthenticationProvider authProvider = new DaoAuthenticationProvider();
        authProvider.setPasswordEncoder(passwordEncoder());
        authProvider.setUserDetailsService(customUserDetailsService);
        return authProvider;
    }

    @Bean
    public PersistentTokenRepository persistentTokenRepository() {
        JdbcTokenRepositoryImpl  jdbcTokenRepositoryImpl = new JdbcTokenRepositoryImpl();
        jdbcTokenRepositoryImpl.setDataSource(dataSource);
        return jdbcTokenRepositoryImpl;
    }

    @Bean
    public SavedRequestAwareAuthenticationSuccessHandler savedRequestAwareAuthenticationSuccessHandler () {
        SavedRequestAwareAuthenticationSuccessHandler authenticationSuccessHandler = new SavedRequestAwareAuthenticationSuccessHandler();
        authenticationSuccessHandler.setTargetUrlParameter("targetUrl");
        return authenticationSuccessHandler;
    }

    @Autowired
    public void configureGlobal(AuthenticationManagerBuilder auth) {
        auth.authenticationProvider(authProvider());
    }
}

ResourceServerConfig.class

@Configuration
@EnableResourceServer
@Order(2)
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {

    private Logger log = LoggerFactory.getLogger(ResourceServerConfig.class);

    @Override
    public void configure(ResourceServerSecurityConfigurer resources) {
        resources
            .resourceId("recursoUno");
    }


    @Override
    public void configure(HttpSecurity http) throws Exception {

        log.info("Configurando http security oauth");

        // Indica los recursos a proteger
        http.authorizeRequests()
                    .antMatchers("/api/v1.0/secure").hasRole("ADMIN")
                    .antMatchers("/api/v1.0/**").authenticated();

        // Configurar el estado de la sesion oauth como stateless
        http.sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS);

        // Habilitar csrf para oauth
        /*http.csrf()
                .requireCsrfProtectionMatcher(new AntPathRequestMatcher("/oauth/authorize"))
                .disable();*/


        /*http.authorizeRequests()
                .antMatchers("/api/v1.0/secure").hasRole("ADMIN")
                .antMatchers("/api/v1.0/**").permitAll();*/

        // Configura el logout
        /*http.logout()
                .logoutUrl("/oauth/logout");*/
    }
}

Hi, I have the following code in the application-context of my project.

bean id="bean" class="ej.tutorial.spring.model.MyBean" />
<bean id="beanSvc" class="ej.tutorial.spring.model.OtherBean">
<property name="mBean" ref="bean"/>
</bean>

The classes are the following:

public class MyBean {

private int valor;
private String msg;

public MyBean(){

}

public MyBean(int valor,String msg){
    this.valor = valor;
    this.msg = msg;
}

public int getValor() {
    return valor;
}

public void setValor(int valor) {
    this.valor = valor;
}

public String getMsg() {
    return msg;
}

public void setMsg(String msg) {
    this.msg = msg;
   }
}

OtherBean class:

public class OtherBean {

private MyBean mBean;

public OtherBean(){

}

public OtherBean(MyBean bean){
    this.mBean = bean;
}

public MyBean getmBean() {
    return mBean;
}

public void setmBean(MyBean mBean) {
    this.mBean = mBean;
    }

}

Well, the application-context gives me an error. The error is the following.

No setter found for property 'mBean' in class 'ej.tutorial.spring.model.OtherBean

The truth is that I can't find a logical explanation for it since the setter of the mBean attribute is defined in the OtherBean class.

Suppose I have the following JPA repository:

public interface IGreetingRepository extends JpaRepository<Greeting, Long> {
}

And according to the documentation you would have to generate a service interface as follows:

public interface IGreetingService {

    Greeting getGreetingById(Long id);

    List<Greeting> getAllGreetings();

    Greeting saveGreeting(Greeting greeting);

    void deleteGreeting(Long id);

}

And after the implementation:

@Service
@Qualifier("greetingService")
public class GreetingServiceImpl implements IGreetingService {

    @Autowired
    @Qualifier("greetingRepository")
    IGreetingRepository greetingRepository;

    @Override
    public Greeting getGreetingById(Long id) {
        return greetingRepository.findOne(id);
    }

    @Override
    public List<Greeting> getAllGreetings() {
        return greetingRepository.findAll();
    }

    @Override
    public Greeting saveGreeting(Greeting greeting) {
        return greetingRepository.save(greeting);
    }

    @Override
    public void deleteGreeting(Long id) {
        greetingRepository.delete(id);
    }
}

And to make use of my service in my controllers I would inject it like this:

@Autowired
@Qualifier("greetingService")
GreetingService greetingService;

What I don't understand is, what is the advantage of doing it like this instead of directly injecting the JPA repository interface and saving me the 2 classes?:

@Autowired
@Qualifier("greetingRepository")
IGreetingRepository greetingRepository;

I would need to be able to add a time type field with gvNIX... I have seen that the datetime tagx exists, but it does not allow me to select the hours....

I am using version 1.4.1 of gvNIX