Architecture Logicielle

Cours 6

Services génériques avec

JEE

Année universitaire 2019/2020

1
Modèles

2
Classe model générique
@MappedSuperclass
@SuppressWarnings("serial")
public class BaseModel implements Serializable {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Basic(optional = false)
@Column(name = "id", nullable = false, columnDefinition = "BIGINT")
private long id;

public long getId() {

return id;
}

public void setId(long id) {

this.id = id;
}

}
3
Classe Grant
@Entity
@Table(name="restapi_grants")
@JsonIgnoreProperties({"hibernateLazyInitializer", "
handler"})
public class Grant extends BaseModel {

private static final long serialVersionUID = 419

2997147639777673L;

@Column(name="grant_name")
private String name;

@Column(name="grant_key")
private String grantKey;
}
4
Classe role
@Entity
@Table(name="restapi_roles")
@JsonIgnoreProperties({"hibernateLazyInitializer", "handler"})
public class Role extends BaseModel{

private static final long serialVersionUID = -1938567246027507296L;

@Column(name="role_name")
private String name;

@Column(name="role_key")
private String roleKey;

@Column(name="is_active")
private boolean isActive;

public String getName() {

return name;
}

5
DAO

6
Interface BaseDao

public interface BaseDao<T extends BaseModel> extends

JpaRepository<T, Serializable> {

7
interface GrantDao

public interface GrantDao extends BaseDao<Grant>

{

8
Interface RoleDao

public interface RoleDao extends BaseDao<Role> {

9
Controller

10
class GenericRestController
public class GenericRestController<T extends BaseModel> {

@Autowired
private BaseDao<T> dao;

@RequestMapping(method = RequestMethod.GET)
public List<T> list() {
return dao.findAll();
}

@RequestMapping(method = RequestMethod.POST)
public T create(@RequestBody T entity) {
return dao.save(entity);
}

@RequestMapping(value = "{id}", method = RequestMethod.PUT)

public T update(@PathVariable(value = "id") long id, @RequestBody T en
tity) {
return dao.save(entity);
}

11
class GenericRestController
@RequestMapping(value = "{id}", method = RequestMethod.DELETE)
public void delete(@PathVariable(value = "id") long id) {
dao.delete(id);
}

@RequestMapping(value = "{id}", method = RequestMethod.GET)

public T get(@PathVariable(value = "id") long id) {
return dao.getOne(id);
}
}

12
class GrantController

@RequestMapping("/grants")
public class GrantController extends GenericRestCont
roller<Grant> {

13
class RoleController

@RestController
@RequestMapping("/roles")
public class RoleController extends GenericRestContro
ller<Role> {

14
Site e-commerce

15
Modèles

16
class Client
@Entity
@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class Client {
@Id @GeneratedValue(strategy = GenerationType.IDENT
ITY)
private Long id;
private String name;
private String email;
private String address;
private String phoneNumber;
private String username;
}

17
class Product
@Entity
@Data @NoArgsConstructor @AllArgsConstructor @ToString
public class Product implements Serializable {
@Id @GeneratedValue(strategy = GenerationType.IDENTIT
Y)
private Long id;
private String name;
private String description;
private double currentPrice;
private boolean promotion;
private boolean selected;
private boolean available;
private String photoName;
@Transient
private int quantity=1;
@ManyToOne
private Category category;
} 18
class Category

@Entity
@Data @NoArgsConstructor @AllArgsConstructor
public class Category implements Serializable {
@Id @GeneratedValue(strategy = GenerationType.IDENTIT
Y)
private Long id;
private String name;
private String photo;
private String description;
@OneToMany(mappedBy = "category")
private Collection<Product> products;
}

19
class Order

@Entity
@Table(name="orders")
@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class Order {
@Id @GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private Date date;
@OneToMany(mappedBy = "order")
private Collection<OrderItem> orderItems;
@ManyToOne
private Client client;
private double totalAmount;
@OneToOne
private Payment payment;
}
20
class OrderItem
@Entity
@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class OrderItem {
@Id @GeneratedValue(strategy = GenerationType.IDEN
TITY)
private Long id;
@ManyToOne
private Product product;
private int quantity;
private double price;
@ManyToOne
@JsonProperty(access = JsonProperty.Access.WRITE_O
NLY)
private Order order;
} 21
class Payment
@Entity
@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class Payment {
@Id @GeneratedValue(strategy = GenerationType.IDENTIT
Y)
private Long id;
private Date datePayment;
private long cardNumber;
private String cardType;
@OneToOne(mappedBy = "payment")
@JsonProperty(access = JsonProperty.Access.WRITE_ONLY
)
private Order order;

} 22
DAO

23
interface ClientRepository

@CrossOrigin("*")
@RepositoryRestResource
public interface ClientRepository extends JpaRepository
<Client, Long> {

24
interface ProductRepository
@CrossOrigin("*")
@RepositoryRestResource
public interface ProductRepository extends JpaRepository
<Product, Long> {
@RestResource(path = "/selectedProducts")
public List<Product> findBySelectedIsTrue();
@RestResource(path = "/productsByKeyword")
public List<Product> findByNameContains
(@Param("mc") String mc);
@RestResource(path = "/promoProducts")
public List<Product> findByPromotionIsTrue();
@RestResource(path = "/dispoProducts")
public List<Product> findByAvailableIsTrue();
}

25
interface CategoryRepository

@CrossOrigin("*")
@RepositoryRestResource
public interface CategoryRepository extends JpaRepository
<Category, Long> {
}

26
interface OrderRepository
@CrossOrigin("*")
@RepositoryRestResource
public interface OrderRepository extends JpaRepository<Orde
r, Long> {

27
interface OrderItemRepository

@CrossOrigin("*")
@RepositoryRestResource
public interface OrderItemRepository extends JpaReposi
tory<OrderItem, Long> {

28
interface PayementRepository

@CrossOrigin("*")
@RepositoryRestResource
public interface PayementRepository extends JpaRepository
<Payment, Long> {

29
 Web &
Controllers
30
class CatalogueRestController
@CrossOrigin("*")
@RestController
public class CatalogueRestController {
private ProductRepository productRepository;

public CatalogueRestController(ProductRepository pr
oductRepository) {
this.productRepository = productRepository;
}

31
class CatalogueRestController

@GetMapping(path="/photoProduct/{id}",produces = MediaType.IM
AGE_PNG_VALUE)

public byte[] getPhoto(@PathVariable("id") Long id) throws

Exception{

Product p=productRepository.findById(id).get();

return Files.readAllBytes(Paths.get(System.getProperty(

"user.home")+"/ecom/products/"+p.getPhotoName()));}

32
class CatalogueRestController

@PostMapping(path = "/uploadPhoto/{id}")

public void uploadPhoto(MultipartFile file,

@PathVariable Long id) throws Exception{

Product p=productRepository.findById(id).get();
p.setPhotoName(file.getOriginalFilename());

Files.write(Paths.get(System.getProperty("user.home")+
"/ecom/products/"+p.getPhotoName()),file.getBytes());
productRepository.save(p);
}
}

33
OrderFrom
@Data
public class OrderForm {
private Client client=new Client();
private List<OrderProduct> products=new ArrayList<
>();
}
@Data
class OrderProduct{
private Long id;
private int quantity;

34
class OrderController
@CrossOrigin("*")
@RestController
public class OrderController {
@Autowired
private ProductRepository productRepository;
@Autowired
private ClientRepository clientRepository;
@Autowired
private OrderRepository orderRepository;
@Autowired
private OrderItemRepository orderItemRepository;
@PostMapping("/orders")
public Order saveOrder(@RequestBody OrderForm orderForm){
Client client=new Client();
client.setName(orderForm.getClient().getName());
client.setEmail(orderForm.getClient().getEmail());
client.setAddress(orderForm.getClient().getAddress());
client.setPhoneNumber(orderForm.getClient().getPhoneNumber());
35
class OrderController
client.setUsername(orderForm.getClient().getUsername());
client=clientRepository.save(client);
System.out.println(client.getId());
Order order=new Order();
order.setClient(client);
order.setDate(new Date());
order=orderRepository.save(order);
double total=0;
for(OrderProduct p:orderForm.getProducts()){
OrderItem orderItem=new OrderItem();
orderItem.setOrder(order);
Product product=productRepository.findById(p.getId
()).get();

36
class OrderController
orderItem.setProduct(product);
orderItem.setPrice(product.getCurrentPrice());
orderItem.setQuantity(p.getQuantity());
orderItemRepository.save(orderItem);
total+=p.getQuantity()*product.getCurrentPrice();
}
order.setTotalAmount(total);
return orderRepository.save(order);
}

37
Architecture Logicielle

Cours 7

Services génériques avec

TypeSript

Année universitaire 2019/2020

38
Modèles

39
class Bookmark
export class Bookmark {

private id: number;

private url: string;
private description: string;

constructor(id: number, url: string, description:

string) {
this.id = id;
this.url = url;
this.description = description;
}

40
Interface Générique

41
interface CrudOperations

export interface CrudOperations<T, ID> {

save(t: T): Observable<T>;
update(id: ID, t: T): Observable<T>;
findOne(id: ID): Observable<T>;
findAll(): Observable<T[]>;
delete(id: ID): Observable<any>;
}

42
abstract class CrudService

export abstract class CrudService<T, ID> implements CrudOperatio

ns<T, ID> {

constructor(
protected _http: HttpClient,
protected _base: string
) {}

save(t: T): Observable<T> {

return this._http.post<T>(this._base, t);
}
update(id: ID, t: T): Observable<T> {
return this._http.put<T>(this._base + "/" + id, t, {});
}

43
abstract class CrudService

findOne(id: ID): Observable<T> {

return this._http.get<T>(this._base + "/" + id);
}

findAll(): Observable<T[]> {
return this._http.get<T[]>(this._base)
}

delete(id: ID): Observable<T> {

return this._http.delete<T>(this._base + '/' + id);
}

44
@Injectable()
export class BookmarkService extends CrudService<Boo
kmark, number> {

constructor(protected _http: HttpClient) {

super(_http, "http://localhost:8080/api/bookmark
");
}

45
Autre Exemple

46
Classe Compte
export class Compte {

codeCompte:number;
dateCreation:Date;
type_compte:String;
solde:number;
client:Client;

constructor(type_compte:String, dateCreation:Date, s
olde:number, client:Client )

{
this.type_compte=type_compte;
this.dateCreation=dateCreation;
this.solde=solde;
this.client=client;
}
47
class CompteService

export class CompteService {

constructor(private httpClient: HttpClient) { }

readonly host = 'http://localhost:8080/comptes';

public deleteressource(url)

{
return this.httpClient.delete(url);

48
class CompteService
public saveressource(url,data):Observable<Compte>{

return this.httpClient.post<Compte>(url,data);
}
public getressource(url):Observable<Compte>{

return this.httpClient.get<Compte>(url);
}

public editressource(url,data):Observable<Compte>{

return this.httpClient.put<Compte>(url,data);
}
}

49
Ajout d’un compte

This.Compteservice.saveressource(this.Compteservice
.host, data)
.subscribe(res=>{
console.log(res);
},err=>{console.log(err)})

50