sales order system
1.0.0
Projeto não mantido mais ativamente, consulte: Sistema de pedidos de vendas 2.0 em vez disso
Este é um aplicativo Web de pilha completa muito pequena que é usada como uma amostra e é para fins de demonstração pura.
git clone https://github.com/colinbut/sales-order-system.git
mvn clean package
... compilará as fontes, empacotará o arquivo de guerra
Entre no diretório de aplicação on-line e execute o seguinte comando:
mvn tomcat7:run-war
usa o plug -in maven tomcat7 para executar o aplicativo em um contêiner incorporado do Apache Tomcat Web
Depois que o aplicativo é carregado, navegue para:
http://localhost:8080/online-application/login
Algumas credenciais de amostra podem ser encontradas configuradas no arquivo de configuração Application-Security.xml da Spring.
mvn test
... Isso executará todo o teste de unidade dentro do conjunto de testes
ou
Do seu IDE, basta navegar até a aula de teste de unidade e clicar no botão 'Run' do IDE
mvn verify
... Isso executará todo o teste de integração dentro do conjunto de testes.
ou
Do seu IDE, basta navegar até a aula de teste de integração e clicar no botão 'Run' do IDE
[TBD]
Use Sonar (Sonarqube) para executar a análise de qualidade do código no projeto. Um arquivo de protores de sonar. Propriedades fornecidas. Precisará de Sonarqube Server e Sonar Runner, portanto, precisará baixá -los no site Sonarqube e seguir as instruções de instalação.
Supondo que o sonar seja instalado (com o Sonar Runner no caminho do meio ambiente), na CLI Run:
sonar-runner
Também é possível correr com o MySQL. Você precisa que o MySQL seja instalado. Faça o download do site do MySQL e siga as instruções de instalação.
Descomamento abaixo, conforme especificado:
<!-- 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 >Assumming MongoDB está instalado no sistema. Caso contrário, pode baixá -lo no site do MongoDB e seguir as instruções de instalação.
Inicie o servidor de banco de dados MongoDB:
./mongod
Abra o cliente de banco de dados MongoDB:
./mongo
Carregue o arquivo JavaScript MongoDB que preenche alguns dados de amostra
load("mongodb.js")
O aplicativo é apenas um aplicativo monolítico simplista criado com várias camadas. Em resumo, o back-end é escrito em Java, que se conecta a um banco de dados relacional na memória (HSQL). Também pode se conectar a outros bancos de dados relacionais (MySQL). A aplicação é escoldada pela Spring Framework. O padrão arquitetônico do Model-View-Controller (MVC) é usado para separar o front-end do back-end. Isso é conseguido pelo Spring Web MVC. Este aplicativo seria implantado em um contêiner da web incorporado (Apache Tomcat).
O front-end é claramente JSP com um pouco de JSTL aqui e ali. Os bancos de dados de dente -de -leão também usados para implementar tabelas na interface do usuário. CSS básico para estilo. O Bootstrap fornece a estrutura front-end para isso.
[TBD]
Este aplicativo é muito simples. É um aplicativo da Web que atualmente fornece operações básicas de CRUD. Tudo operacional é visto como uma transação comercial que é executada através das várias camadas. Portanto, um modelo de domínio anêmico é usado em oposição a um modelo de domínio puro orientado a objetos. Isso é suficiente e ideal, porque neste momento não há muito (se houver) processamento de lógica de negócios complexa necessária.
Definindo o limite do aplicativo e definir as operações disponíveis a partir da perspectiva das camadas do cliente de interface (front-end). Ele encapsula a lógica de negócios do aplicativo, controlando as transações e as respostas dinadoras da COOR na implementação de suas operações.
por exemplo
@ Service ( "itemServiceImpl" )
@ Transactional
public class ItemServiceImpl implements ItemService {
@ Autowired
private ItemRepository itemRepository ;
...
}Uma visão orientada a objetos do armazenamento de dados abaixo, fornecendo uma camada extra de abstração (Spring Data JPA) na frente dos recursos de acesso a dados do padrão de mapeador de dados. A estrutura de mapeamento relacional de objetos (hibernato) é usada para alcançar esse efeito de mapear as diferenças entre as tabelas de banco de dados relacionais e o modelo de domínio. O Entity Manager da JPA encapsula o elemento de acesso a dados (padrão do objeto de acesso a dados).
por exemplo, um repositório JPA de dados de primavera
@ Repository
public interface ItemRepository extends JpaRepository < Item , Integer > {
}O suporte à anotação da Spring Framework (varredura de componentes) é feito para fazer isso aproveitando as habilidades centrais da Spring Framework - injeção de dependência fornecida pela inversão do contêiner de controle (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 ;Outro exemplo do objeto Modelo do Cliente:
@ 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 ;Projeto Lombok usado para gerar getters/setters/tostring/igual e hashcode para remover o código da caldeira
O aplicativo permite o recurso de login/logout que foi implementado usando os recursos básicos do módulo de segurança da primavera da estrutura da mola.
O seguinte arquivo de configuração de spring de aplicativo-security.xml mostra as configurações de segurança das chaves:
< 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 >O teste de integração é implementado usando a estrutura de contexto de teste da Spring. Um banco de dados de memória (HSQL) é usado.
Teste final de final 2 (teste de aceitação) é realizado usando o pepino-JVM. Isso está disponível no sub-módulo de automação de teste. A intenção disso é fornecer automação de ponta a ponta do aplicativo Web de pilha completa. Talvez possa integrar o selênio no futuro, o que permitiria a automação do aplicativo da Web nos navegadores da Web. Mas, por enquanto, os testes de pepino estão gravados no código de back-end. Os critérios de aceitação são escritos nos arquivos .Feature usando a linguagem Gherkin. Esta área precisa de melhorias. Observe que os testes finais do final 2 para este projeto ainda estão limpos.
Eu ([email protected])
[TBD]
| Front-end | Back -end | Banco de dados | Teste | Outro |
|---|---|---|---|---|
| Html | Java 8 | HSQL (HyperSQL) | Junit | SLF4J - LOG4J |
| CSS | Núcleo da primavera | Mysql | Assertj | Maven |
| JS | Spring Web MVC | MongoDB | Mockito | Tomcat |
| Bootstrap | Dados da primavera JPA | Pepino-jvm | Sonarqube | |
| JSP | Segurança da primavera | Contexto de teste de primavera | Lombok | |
| Jstl | JPA - Hibernate | |||
| Data de dente -de -leão | JTA | |||
| Validação de feijão |
