Loading repository data…
AugustoMello09 / repository
Estudo sobre a implementação do modelo conceitual. (Curso Projeto full stack completo! Java Spring Boot no back end e Ionic no front end do Prof. Dr. Nelio Alves)Seção 1: Implementação do modelo conceitual.
começando pela categoria.
@RestController
@RequestMapping(value = "/categorias")
public class CategoriaResource {
@RequestMapping(method = RequestMothod.GET)
public String listar(){
return "REST está funcionando";
}
}
Criando nossa primeira entidade e colocando no pacote domain. Obs:Nela também acompanha Construtores, Getters, Setters e hashCode, mas não foi colocado na parte da documentação para não atrapalhar a visualização.
public class Categoria implements Serializable{
private static final long serialVersionUID = 1L;
private Integer id;
private String nome;
}
Fazendo atualização no método de listar.
@RequestMapping(method = RequestMothod.GET)
public List<Categoria> listar(){
Categoria cat1 = new Categoria(1, "Informática");
Categoria cat2 = new Categoria(2,"Escritório");
List<Categoria> lista = new ArrayList<>();
lista.add(cat1);
lista.add(cat2);
return lista;
}
colocando as Anotações na classe Categoria para gerar no Banco
@Entity
public class Categoria implements Serializable{
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue (strategy = GenerationType.IDENTITY)
private Integer id;
private String nome;
}
Criando um Repository para acessar as categorias
@Repository
public interface CategoriaRepository extends JpaRepository<Categoria, Integer> {
}
A camada Service vai servir de operações e consultas para Categoria e implantado um serviço que busca uma Categoria.
@Service
public class CategoriaService {
@Autowired/*A dependência e automaticamente instanciada pelo Spring */
private CategoriaRepository repo;
public Categoria find(Integer id) {
Optional<Categoria> obj = repo.findById(id);
return obj.orElse(null);
}
}
Atualizando para os controladores serem capazes de buscar uma Categoria.
@RestController
@RequestMapping(value = "/categorias")
public class CategoriaResource {
@Autowired
private CategoriaService service;
@RequestMapping(value ="/{id}", method = RequestMethod.GET)
public ResponseEntity<?> find(@PathVariable Integer id) {
Categoria obj = service.find(id);
return ResponseEntity.ok().body(obj);
}
}
Incluindo manualmente no banco teste H2
INSERT INTO CATEGORIA(NOME) VALUES ('Informática');
INSERT INTO CATEGORIA(NOME) VALUES ('Escritório');
SELECT * FROM CATEGORIA
/categorias/1
/categorias/2
para não ter o trabalho de instanciar manualmente os objetos Categoria no banco de dados, vamos fazer isso automaticamente.
@Autowired
private CategoriaRepository categoriaRepository;
public static void main(String[] args) {
SpringApplication.run(EstudomcApplication.class, args);
}
@Override
public void run(String... args) throws Exception {
Categoria cat1 = new Categoria(null, "Informática");
Categoria cat2 = new Categoria(null, "Escritório");
categoriaRepository.saveAll(Arrays.asList(cat1, cat2));
}
Fazendo as associações entra elas e instanciar os objetos. Obs:Nela também acompanha Construtores, Getters, Setters e hashCode, mas não foi colocado na parte da documentação para não atrapalhar a visualização.
@Entity
public class Produto implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy =GenerationType.IDENTITY)
private Integer id;
private String nome;
private Double preco;
@ManyToMany
@JoinTable(name = "PRODUTO_CATEGORIA",
joinColumns = @JoinColumn(name= "produto_id"),
inverseJoinColumns = @JoinColumn(name = "categoria_id"))
private List<Categoria> categorias = new ArrayList<>();
}
@Repository
public interface ProdutoRepository extends JpaRepository<Produto, Integer> {
}
@Autowired
private ProdutoRepository produtoRepository;
Produto p1 = new Produto(null, "Computador", 2000.00);
Produto p2 = new Produto(null, "Impressora", 800.00);
Produto p3 = new Produto(null, "Mouse", 80.00);
cat1.getProdutos().addAll(Arrays.asList(p1, p2, p3));
cat2.getProdutos().addAll(Arrays.asList(p2));
p1.getCategorias().addAll(Arrays.asList(cat1));
p2.getCategorias().addAll(Arrays.asList(cat1, cat2));
p3.getCategorias().addAll(Arrays.asList(cat1));
categoriaRepository.saveAll(Arrays.asList(cat1, cat2));
produtoRepository.saveAll(Arrays.asList(p1, p2, p3));
Testando no H2 o relacionamento
@JsonManagedReference
@ManyToMany(mappedBy = "categorias")
private List<Produto> produtos = new ArrayList<>();
@JsonBackReference
@ManyToMany
@JoinTable(name = "PRODUTO_CATEGORIA",
joinColumns = @JoinColumn(name= "produto_id"),
inverseJoinColumns = @JoinColumn(name = "categoria_id"))
private List<Categoria> categorias = new ArrayList<>();
Incluindo um tratamento de Exceções, agora o método de serviço ele lança uma exceção caso o Id não exista.
public Categoria find(Integer id) {
Optional<Categoria> obj = repo.findById(id);
return obj.orElseThrow(() -> new ObjectNotFoundException(
"Objeto não encontrado! Id: " + id + ", Tipo: " + Categoria.class.getName()));
}
Como não é uma boa prática colocar blocos de try catch no controladores REST, vamos fazer um Handler que é um objeto especial que vai interceptar e vai lançar a resposta Http correta.
@ControllerAdvice
public class ResourceExceptionHandler {
@ExceptionHandler(ObjectNotFoundException.class)
public ResponseEntity<StandardError> objectNotFound(ObjectNotFoundException e, HttpServletRequest request){
StandardError err = new StandardError(HttpStatus.NOT_FOUND.value(), e.getMessage(), System.currentTimeMillis());
return ResponseEntity.status(HttpStatus.NOT_FOUND).body(err);
}
}
public class StandardError implements Serializable {
private static final long serialVersionUID = 1L;
private Integer status;
private String msg;
private Long timeStamp;
}
Com o relacionamento de muitos para um. Obs:Nela também acompanha Construtores, Getters, Setters e hashCode, mas não foi colocado na parte da documentação para não atrapalhar a visualização.
@Entity
public class Cidade implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer id;
private String nome;
@ManyToOne
@JoinColumn(name ="estado_id")
private Estado estado;
}
@Repository
public interface CidadeRepository extends JpaRepository<Cidade, Integer> {
}
@Autowired
private CidadeRepository cidadeRepository;
Cidade c1 = new Cidade(null, "Uberlândia", est1);
Cidade c2 = new Cidade(null, "São Paulo", est2);
Cidade c3 = new Cidade(null, "Campinas", est2);
cidadeRepository.saveAll(Arrays.asList(c1, c2, c3));
Com o relacionamento de um para muitos. Obs:Nela também acompanha Construtores, Getters, Setters e hashCode, mas não foi colocado na parte da documentação para não atrapalhar a visualização.
@Entity
public class Estado implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer id;
private String nome;
@OneToMany(mappedBy = "estado")
private List<Cidade> cidade = new ArrayList<>();
}
@Repository
public interface EstadoRepository extends JpaRepository<Estado, Integer> {
}
@Autowired
private EstadoRepository estadoRepository;
Estado est1 = new Estado(null, "Minas Gerais");
Estado est2 = new E
Selected from shared topics, language and repository description—not editorial ratings.
AugustoMello09 /
Estudo sobre uma aplicação Backend. (Curso Projeto full stack completo! Java Spring Boot no back end e Ionic no front end do Prof. Dr. Nelio Alves)