sales order system
1.0.0
Le projet n'est plus activement maintenu, veuillez consulter: Sales Système de commande 2.0 à la place
Il s'agit d'une très petite application Web complète qui est utilisée comme échantillon et est à des fins de démonstration pure.
git clone https://github.com/colinbut/sales-order-system.git
mvn clean package
... compilera les sources, emballera le fichier de guerre
Allez dans le répertoire de l'application en ligne et exécutez la commande suivante:
mvn tomcat7:run-war
Utilise le plugin Maven Tomcat7 pour exécuter l'application dans un conteneur Web Apache Tomcat intégré
Une fois l'application chargée, accédez à:
http://localhost:8080/online-application/login
Certains exemples d'identification peuvent être trouvés configurés dans le fichier de configuration Application-Security.xml de Spring.
mvn test
... Cela exécutera tous les tests unitaires dans la suite de tests
ou
Depuis votre IDE, accédez simplement à la classe de test unitaire et cliquez sur le bouton «Exécuter» de l'IDE
mvn verify
... Cela exécutera tous les tests d'intégration dans la suite de tests.
ou
Depuis votre IDE, accédez simplement à la classe de test d'intégration et cliquez sur le bouton «Exécuter» de l'IDE
[TBD]
Utilisez sonar (Sonarqube) pour exécuter une analyse de la qualité du code sur le projet. Un fichier sonar-project.properties fourni. Aura besoin de serveur Sonarqube et de coureur de sonar, il faut donc les télécharger à partir du site Web Sonarqube et suivre les instructions d'installation.
En supposant que le sonar est installé (avec sonar coureur sur le chemin de l'environnement), sur CLI Run:
sonar-runner
Il est également possible de fonctionner avec MySQL. Vous avez besoin d'installer MySQL. Téléchargez à partir du site Web MySQL et suivez les instructions d'installation.
Certes ci-dessous comme spécifié:
<!-- uncomment out for use with MySQL database -->
< bean id = " dataSource " class = " org.springframework.jdbc.datasource.DriverManagerDataSource " >
< property name = " driverClassName " value = " com.mysql.jdbc.Driver " />
< property name = " url " value = " jdbc:mysql://localhost:3306/sales_order_system " />
< property name = " username " value = " root " />
< property name = " password " value = " " />
</ bean >
< jdbc : initialize-database ignore-failures = " DROPS " >
< jdbc : script location = " file:src/main/resources/scripts/db-drop-tables.sql " />
< jdbc : script location = " file:src/main/resources/scripts/db-create.sql " />
</ jdbc : initialize-database >Assist MongoDB est installé sur le système. Sinon, peut le télécharger à partir du site Web MongoDB et suivre les instructions d'installation.
Démarrer le serveur de base de données MongoDB:
./mongod
Ouvrez le client de base de données MongoDB:
./mongo
Chargez le fichier JavaScript MongoDB qui remplit quelques exemples de données
load("mongodb.js")
L'application n'est qu'une application monolithique simpliste construite avec plusieurs couches. En résumé, le back-end est écrit en Java qui se connecte à une base de données relationnelle en mémoire (HSQL) back-end. Peut également se connecter à d'autres bases de données relationnelles (MySQL). L'application est scafold par Spring Framework. Le modèle architectural du modèle de View-Controller (MVC) est utilisé pour séparer le front-end du back-end. Ceci est réalisé par Spring Web MVC. Cette application serait ensuite déployée sur un conteneur Web intégré (Apache Tomcat).
Le frontal est clairement JSP avec un peu de JSTL ici et là. Les bases de données de pissenlit ont également utilisé pour implémenter des tables dans l'interface utilisateur. CSS de base pour le style. Bootstrap fournit le cadre frontal pour cela.
[TBD]
Cette application est très simple. Il s'agit d'une application Web qui fournit actuellement des opérations CRUD de base. Tout ce qui est opérationnel est considéré comme une transaction commerciale qui est exécutée à travers les différentes couches. Par conséquent, un modèle de domaine anémique est utilisé par opposition à un modèle de domaine pur orienté objet. Ceci est suffisant et idéal car en ce moment, il n'y a pas beaucoup de traitement de logique métier complexe (le cas échéant) qui est nécessaire.
Définir la limite de l'application et définir les opérations disponibles du point de vue de l'interfaçage des couches client (front-end). Il résume la logique métier de l'application, le contrôle des transactions et les réponses coor-dinantes dans la mise en œuvre de ses opérations.
par exemple
@ Service ( "itemServiceImpl" )
@ Transactional
public class ItemServiceImpl implements ItemService {
@ Autowired
private ItemRepository itemRepository ;
...
}Une vue axée sur l'objet du magasin de données en dessous fournissant une couche supplémentaire d'abstraction (printemps data jpa) devant les capacités d'accès aux données du modèle de mappeur de données. Le cadre de mappage relationnel d'objet (Hibernate) est utilisé pour réaliser cet effet de cartographie des différences entre les tables de base de données relationnelles et le modèle de domaine. Entity Manager de JPA résume l'élément d'accès aux données (modèle d'objet d'accès aux données).
par exemple d'un référentiel JPA de données printanier
@ Repository
public interface ItemRepository extends JpaRepository < Item , Integer > {
}Le support d'annotation de Spring Framework (composant) est effectué pour que cela profite des capacités de base de Spring Framework - injection de dépendance fournie par le conteneur d'inversion du contrôle (IOC).
@ Controller
public class OrderController {
private static final Logger logger = LoggerFactory . getLogger ( OrderController . class );
@ Autowired
@ Qualifier ( "orderServiceImpl" )
private OrderService orderService ;
@ Autowired
@ Qualifier ( "customerServiceImpl" )
private CustomerService customerService ;
@ Autowired
@ Qualifier ( "itemServiceImpl" )
private ItemService itemService ;
@ Autowired
@ Qualifier ( "orderFormValidator" )
private OrderFormValidator orderFormValidator ;Un autre exemple de l'objet du modèle client:
@ Entity
@ Table ( name = "customer" )
@ Getter
@ Setter
@ NoArgsConstructor
@ EqualsAndHashCode ( exclude = "orders" )
@ ToString
public class Customer {
@ Id
@ GeneratedValue ( strategy = GenerationType . IDENTITY )
@ Column ( name = "customer_id" )
private int customerId ;
@ NotNull ( message = "{error.null.firstname}" )
@ NotBlank ( message = "{error.blank.firstname}" )
@ NotEmpty ( message = "{error.empty.firstname}" )
@ Pattern ( regexp = "[a-zA-Z]*" , message = "{error.invalid.firstname}" )
@ Column ( name = "customer_firstname" , nullable = false , length = 50 )
private String firstName ;
@ NotNull ( message = "{error.null.lastname}" )
@ NotBlank ( message = "{error.blank.lastname}" )
@ NotEmpty ( message = "{error.empty.lastname}" )
@ Pattern ( regexp = "[a-zA-Z]*" , message = "{error.invalid.lastname}" )
@ Column ( name = "customer_lastname" , nullable = false , length = 50 )
private String lastName ;Lombok Project utilisé pour générer des Getters / Setters / Tostring / Equals et HashCode pour supprimer le code du passe-partout
L'application permet la fonction de connexion / déconnexion qui a été implémentée à l'aide des fonctionnalités de base du module de sécurité Spring du framework Spring.
Le fichier de configuration Spring Application-Security.xml suivant affiche des configurations de sécurité clés:
< beans : beans xmlns = " http://www.springframework.org/schema/security "
xmlns : beans = " http://www.springframework.org/schema/beans "
xmlns : xsi = " http://www.w3.org/2001/XMLSchema-instance "
xsi : schemaLocation = " http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/security
http://www.springframework.org/schema/security/spring-security-3.2.xsd " >
< http auto-config = " true " >
<!-- items -->
< intercept-url pattern = " /items " access = " ROLE_TEST_USER,ROLE_ADMIN " />
< intercept-url pattern = " /items/create " access = " ROLE_TEST_USER,ROLE_ADMIN " />
< intercept-url pattern = " /items/createItem " access = " ROLE_TEST_USER,ROLE_ADMIN " />
....
< form-login
login-page = " /login "
default-target-url = " /customers "
authentication-failure-url = " /login?error "
username-parameter = " username "
password-parameter = " password "
/>
< logout logout-success-url = " /login?logout " />
< csrf />
</ http >
< authentication-manager >
< authentication-provider >
< user-service >
<!-- hard coding application user credentials - switch to DB or LDAP -->
< user name = " testUser " password = " password " authorities = " ROLE_TEST_USER " />
< user name = " admin " password = " password " authorities = " ROLE_ADMIN " />
</ user-service >
</ authentication-provider >
</ authentication-manager >
</ beans : beans >Les tests d'intégration sont implémentés à l'aide du cadre de contexte de test de Spring. Une base de données en mémoire (HSQL) est utilisée.
Fin 2 Les tests de fin (test d'acceptation) se font à l'aide du concombre-JVM. Ceci est disponible sous le sous-module d'automation de test. L'intention est de fournir une automatisation de bout en bout de l'application Web complète. Peut-être que peut intégrer le sélénium à l'avenir, ce qui permettrait l'automatisation de l'application Web sur les navigateurs Web. Mais pour l'instant, les tests de concombre sont écrits dans le code back-end. Les critères d'acceptation sont écrits dans les fichiers .Feature à l'aide de la langue gherkin. Cette zone doit être améliorée. Notez que les tests de fin de fin de ce projet sont toujours WIP.
Moi ([email protected])
[TBD]
| L'extrémité avant | Arrière | Base de données | Essai | Autre |
|---|---|---|---|---|
| Html | Java 8 | HSQL (Hypersql) | Junite | Slf4j - log4j |
| CSS | Noyau de printemps | Mysql | Affirmer | Maven |
| Js | Spring Web MVC | Mongodb | Mockito | Matou |
| Amorce | Données de printemps JPA | Concombre-JVM | Sonarqube | |
| Jsp | Sécurité du printemps | Contexte de test de printemps | Lombok | |
| JSTL | JPA - Hibernate | |||
| Dandelion DataTables | JTA | |||
| Validation des haricots |
