Spring Security e OAuth2

giannino1995

il 22 ago 2019, 16:08

3 risposte

giannino1995

Utente Attivo

Iscritto da: dic, 2013

Messaggi:: 479

Spring Security e OAuth2

22 ago 2019, 16:29

Ciao a tutti,
Dovrei realizzare una webapp in Spring Boot. L'esercitazione è molto complessa ma la cosa positiva è che ho degli aiuti.
In buona sostanza devo realizzare un'applicazione dinamica in cui una serie di utenti (Marco, Luca e Giovanni, ecc...) già registrati devono autenticarsi mediante un form di login e scrivere dentro un form una coppia di numeri che definiscano la loro posizione sulla superficie terrestre. Queste coordinate ovviamente devono finire in un DB.
In realtà l'applicazione è più complessa ma per quello che devo chiedervi ora è sufficiente.
Faccio una premessa: non amo i framework Java in generale per una serie di motivi e non li ritengo utili ma l'esercitazione richiede l'uso di questi strumenti quindi non mi posso sottrarre. L'esercitazione con JSP e PostgreSQL l'ho già fatta e funziona alla grande, grazie ovviamente all'aiuto del forum e in particolar modo ad andbin, senza di lui nulla sarebbe stato possibile.
La login del sito se ho capito bene la dovrei fare con Spring Security e OAuth2 ma prima di fare tutto ciò devo capire come questi framework lavorano. Per fare ciò mi sono prefissato, prima di tornare all'esercitazione, di riprodurre questo tutorial:
https://dzone.com/articles/secure-spring-rest-with-spring-security-and-oauth2
su cui nutro alcuni dubbi (a mio avviso c'è del codice sbagliato ma potrei sbagliarmi.
Per esempio qui:

INSERT INTO USERS_AUTHORITIES(USER_ID, AUTHORITY_ID) VALUES (1, 9);

AUTHORITY a me risulta che abbia solo 8 campi.
Ad ogni modo ho caricato sul mio IntelliJ tutte le classi e ci sono alcune cose che rimangono in rosso come CompanyService, Company, ecc...
Prima domanda: alcune classi come CompanyService, Company le dovrei scrivere io e nel totorial mancano, giusto?
Seconda domanda: le query ad inizio tutorial le dovrei realizzare dopo aver creato le relative tabelle, giusto?
Terza domanda: dove diamine devo mettere le coordinate del mio DB, manca pure la classe per inizializzare il driver, giusto?
ciao

3 Risposte

giannino1995

Utente Attivo

Iscritto da: dic, 2013

Messaggi:: 479

Re: Spring Security e OAuth2

23 ago 2019, 15:18

Ho provato a caricare il progetto presente su Github:
https://github.com/adamzareba/company-structure-spring-security-oauth2-authorities
senza apportare alcuna modifica ma mancano delle classi (vedere allegato).

Company

package com.adamzareba.spring.security.oauth2.model;

import com.fasterxml.jackson.annotation.JsonManagedReference;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.persistence.UniqueConstraint;

import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;

@Entity
@Table(name = "COMPANY", uniqueConstraints = {@UniqueConstraint(columnNames = {"NAME"})})
@Getter
@Setter
@EqualsAndHashCode(of = "id")
public class Company implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "ID", updatable = false, nullable = false)
    private Long id = null;

    @Column(name = "NAME", nullable = false)
    private String name;

    @OneToMany(cascade = CascadeType.ALL, mappedBy = "company", fetch = FetchType.LAZY, orphanRemoval = true)
    @JsonManagedReference
    private Set<Department> departments = new HashSet<>();

    @OneToMany(cascade = CascadeType.ALL, mappedBy = "company", fetch = FetchType.LAZY, orphanRemoval = true)
    @JsonManagedReference
    private Set<Car> cars = new HashSet<>();

    public void setDepartments(Set<Department> departments) {
        this.departments.clear();
        if (departments != null) {
            this.departments.addAll(departments);
        }
    }

    public void setCars(Set<Car> cars) {
        this.cars.clear();
        if (cars != null) {
            this.cars.addAll(cars);
        }
    }
}

CompanyRepositoryImpl

package com.adamzareba.spring.security.oauth2.repository;

import com.adamzareba.spring.security.oauth2.model.Company;
import com.adamzareba.spring.security.oauth2.model.Company_;
import com.adamzareba.spring.security.oauth2.model.Department;
import com.adamzareba.spring.security.oauth2.model.Department_;
import com.adamzareba.spring.security.oauth2.model.Employee;
import com.adamzareba.spring.security.oauth2.model.Employee_;

import org.springframework.dao.support.DataAccessUtils;
import org.springframework.stereotype.Repository;

import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Fetch;
import javax.persistence.criteria.JoinType;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;

@Repository
public class CompanyRepositoryImpl implements CompanyRepository {

    @PersistenceContext
    private EntityManager entityManager;

    @Override
    public Company find(Long id) {
        CriteriaBuilder builder = entityManager.getCriteriaBuilder();
        CriteriaQuery<Company> query = builder.createQuery(Company.class);

        Root<Company> root = query.from(Company.class);
        root.fetch(Company_.cars, JoinType.LEFT);
        Fetch<Company, Department> departmentFetch = root.fetch(Company_.departments, JoinType.LEFT);
        Fetch<Department, Employee> employeeFetch = departmentFetch.fetch(Department_.employees, JoinType.LEFT);
        employeeFetch.fetch(Employee_.address, JoinType.LEFT);
        departmentFetch.fetch(Department_.offices, JoinType.LEFT);

        query.select(root).distinct(true);
        Predicate idPredicate = builder.equal(root.get(Company_.id), id);
        query.where(builder.and(idPredicate));

        return DataAccessUtils.singleResult(entityManager.createQuery(query).getResultList());
    }

    @Override
    public Company find(String name) {
        CriteriaBuilder builder = entityManager.getCriteriaBuilder();
        CriteriaQuery<Company> query = builder.createQuery(Company.class);

        Root<Company> root = query.from(Company.class);
        root.fetch(Company_.cars, JoinType.LEFT);
        Fetch<Company, Department> departmentFetch = root.fetch(Company_.departments, JoinType.LEFT);
        Fetch<Department, Employee> employeeFetch = departmentFetch.fetch(Department_.employees, JoinType.LEFT);
        employeeFetch.fetch(Employee_.address, JoinType.LEFT);
        departmentFetch.fetch(Department_.offices, JoinType.LEFT);

        query.select(root).distinct(true);
        Predicate idPredicate = builder.equal(root.get(Company_.name), name);
        query.where(builder.and(idPredicate));

        return DataAccessUtils.singleResult(entityManager.createQuery(query).getResultList());
    }

    @Override
    public List<Company> findAll() {
        CriteriaBuilder builder = entityManager.getCriteriaBuilder();
        CriteriaQuery<Company> query = builder.createQuery(Company.class);
        Root<Company> root = query.from(Company.class);
        query.select(root).distinct(true);
        TypedQuery<Company> allQuery = entityManager.createQuery(query);

        return allQuery.getResultList();
    }

    @Override
    public void create(Company company) {
        entityManager.persist(company);
    }

    @Override
    public Company update(Company company) {
        return entityManager.merge(company);
    }

    @Override
    public void delete(Long id) {
        Company company = entityManager.find(Company.class, id);
        delete(company);
    }

    @Override
    public void delete(Company company) {
        entityManager.remove(company);
    }
}

Allegati:

13823_2a23a61d4530fd975981d92ed2088b79.jpg

G
giannino1995
Utente Attivo
Iscritto da
dic, 2013
Messaggi:
479
Re: Spring Security e OAuth2
23 ago 2019, 17:06
Sembra che sia indispensabile un certo plugin di nome lombox ed avviare il processo delle annotazioni. Ho fatto tutto ma queste classi con vengono comunque generate dall'IDE. Mi spiegate cosa sarebbero queste due cose? Praticamente lombox se ho capito bene aggiunge delle classi con del codice all'interno, mi sembra una cosa surreale. Spring che è un framework e dovrebbe semplificare la programmazione complica tutto enormemente. Altra cosa stranissima i metodi che devono essere composti da findBy + un nome scelto dal programmatore. Mi sembra tutto quanto un bella boiata, senza offesa per gli sviluppatori che hanno inventato questa cosa qui.

giannino1995

Utente Attivo

Iscritto da: dic, 2013

Messaggi:: 479

Re: Spring Security e OAuth2

23 ago 2019, 17:24

Ho fatto tutto ciò che viene indicato qui:
https://www.baeldung.com/lombok-id

ma la classe UserIntegrationTest non compare nell'ide e le stringhe rosse restano.
In ogni caso se servisse la dipendenza non vedo perché il programmatore non dovrebbe inserire il codice nel pom.
Ci sono delle evidenti incongruenze? Concordate su questa mia tesi?
https://www.baeldung.com/lombok-id > qui c'è la dipendenza
https://github.com/adamzareba/company-structure-spring-security-oauth2-authorities > qui non c'è la dipendenza
Come faccio a capire come funziona uno script in Spring Boot se non lo posso lanciare e non funziona?
In questo modo imparare ad usare framework in java diventa uno stillicidio.
Scusate lo sfogo sono di cattivo umore...
Ecco il mio file pom.xml con la dipendenza consigliata dal sito spring:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.adamzareba</groupId>
    <artifactId>company-structure-spring-security-oauth2-authorities</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.9.RELEASE</version>
    </parent>

    <properties>
        <java.version>1.8</java.version>
        <h2.version>1.4.196</h2.version>
        <postgresql.version>42.1.4</postgresql.version>

        <spring.version>5.0.2.RELEASE</spring.version>
        <spring.hateoas.version>0.24.0.RELEASE</spring.hateoas.version>

        <hibernate.version>5.2.12.Final</hibernate.version>
        <flywaydb.version>5.0.5</flywaydb.version>
        <jackson.version>2.9.5</jackson.version>
        <lombok.version>1.16.20</lombok.version>
        <oauth2.version>2.2.1.RELEASE</oauth2.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.hateoas</groupId>
            <artifactId>spring-hateoas</artifactId>
            <version>${spring.hateoas.version}</version>
        </dependency>

        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <version>${h2.version}</version>
        </dependency>
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <version>${postgresql.version}</version>
        </dependency>

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-jpamodelgen</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.flywaydb</groupId>
            <artifactId>flyway-core</artifactId>
            <version>${flywaydb.version}</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.datatype</groupId>
            <artifactId>jackson-datatype-hibernate5</artifactId>
            <version>${jackson.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.security.oauth</groupId>
            <artifactId>spring-security-oauth2</artifactId>
            <version>${oauth2.version}</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- Aggiungere la dipendenza per creare alcune classi mancanti nel progetto. -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.8</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.7.0</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                    <!-- <compilerArgument>-Xlint:all</compilerArgument> -->
                    <showWarnings>true</showWarnings>
                    <showDeprecation>true</showDeprecation>
                    <compilerArguments>
                        <processor>
                            org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor,lombok.launch.AnnotationProcessorHider$AnnotationProcessor
                        </processor>
                    </compilerArguments>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

Devi accedere o registrarti per scrivere nel forum

3 risposte