IDEA快速搭建WEB項目【記錄篇】

時間 2019-11-18

標籤 idea 快速搭建 web 項目記錄篇欄目 Eclipse 简体版

原文原文鏈接

這裏用的都是市面上通用的技術，而每一個公司都有本身的調用方式，能夠根據實際狀況與業務場景不一樣去進行變通

三層架構：css

界面層（User Interface layer）、業務邏輯層（Business Logic Layer）、數據訪問層（Data access layer）。區分層次的目的即爲了「高內聚低耦合」的思想。html

Servlet項目

一、靜態資源須要放在WebContent文件下，不該該在web-inf文件下前端

一：項目結構：java

二：底層數據鏈接：mysql

/**
* 數據庫鏈接
* @author 明
*
*/
public class ConnDB {
private static String driver;
private static String url;
private static String user;
private static String pwd;
/**
* 加載鏈接條件
*/
static{
try {
　　Properties properties=new Properties();
　　InputStream inputStream=ConnDB.class.getClassLoader().getResourceAsStream("db.properties");
　　properties.load(inputStream);
　　driver = properties.getProperty("driver");
　　url = properties.getProperty("url");
　　user = properties.getProperty("user");
　　pwd = properties.getProperty("password");
　　Class.forName(driver);
} catch (IOException e) {
　　// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
　　e.printStackTrace();
}

}
/**
* 數據庫鏈接
* @return
*/
public static Connection getConnection(){
　　Connection conn=null;
try {
　　conn=DriverManager.getConnection(url, user, pwd);
} catch (SQLException e) {
　　// TODO Auto-generated catch block
　　e.printStackTrace();
}
　　return conn;
}
/**
* 關閉鏈接屬性
*/
public static void cose(ResultSet resultSet,PreparedStatement preparedStatement,Connection conn){git

if(resultSet!=null){
try {
　　resultSet.close();
} catch (SQLException e) {
　　// TODO Auto-generated catch block
　　e.printStackTrace();
}
}
if(preparedStatement!=null){
try {
　　preparedStatement.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
　　e.printStackTrace();
}
}
if(conn!=null){
try {
　　conn.close();
} catch (SQLException e) {
　　// TODO Auto-generated catch block
　　e.printStackTrace();
}
}
}
}github

數據處理使用工廠方式：加強通用性，會犧牲點性能web

案列：spring

@Override
public Boolean loginUser(String userName, String userPassword) {
　　boolean falg = false;
　　Connection getconn = connDB();
String sql = "select * from user u where u.user_name=? and u.user_password=?";
try {
　　preparedStatement = getconn.prepareStatement(sql);
　　preparedStatement.setString(1, userName);
　　preparedStatement.setString(2, userPassword);
　　resultSet = preparedStatement.executeQuery();
　　while (resultSet.next()) {
　　　　falg = true;
　　}
} catch (SQLException e) {
e.printStackTrace();
}finally {//回收資源
　　ConnectionDBUtil.geetConnClose(resultSet,preparedStatement,connDB());
}
return falg;
}sql

三：數據業務處理：

四：先後臺數據交互：

MVC設計：

小型架構目錄

SSH項目（spring+struts+hibernate）

經常使用註解：

一、Hibernate框架的
Hibernate的註解主要用在持久化類那一塊：

@Entity

指定當前類是實體類。
@Entity
public class User() {
private Integer id;
private String name;
}
@Table

指定實體類和數據庫表之間的對應關係。
屬性：
name：指定數據庫表的名稱
@Entity
@Table(name="t_user")
public class User() {
private Integer id;
private String name;
}
@Id

指定當前字段是主鍵。
@Entity
@Table(name="t_user")
public class User() {
@Id
private Integer id;
private String name;
}
@GeneratedValue

指定主鍵的生成方式。
屬性：
strategy ：指定主鍵生成策略。
JPA 提供的四種標準用法爲 TABLE,SEQUENCE,IDENTITY,AUTO。
@Entity
@Table(name="t_user")
public class User() {
@Id
@GeneratedValue(strategy = IDENTITY)
private Integer id;
private String name;
}
@Column

指定實體類屬性和數據庫表字段之間的對應關係
屬性：
name：指定數據庫表的列名稱。
unique：是否惟一
nullable：是否能夠爲空
inserttable：是否能夠插入
updateable：是否能夠更新
@Entity
@Table(name="t_user")
public class User() {
@Id
@GeneratedValue(strategy = IDENTITY)
@Column(name = "user_id")
private Integer id;

@Column(name = "user_name")
private String name;
}
@Temporal

設置日期時間
1
方式一：@Temporal(TemporalType.DATE)映射爲日期 // birthday date （只有日期）

方式二：@Temporal(TemporalType.TIME)映射爲日期 // birthday time （是有時間）

方式三：@Temporal(TemporalType.TIMESTAMP)映射爲日期 //birthday datetime （日期+時間）

@Temporal(TemporalType.DATE)
private Date birthday;
@Lob
做用：設置大數據類型

方式一：
@Lob
private String text; //text longtext
方式二：

@Lob
private byte[] image; // image longblob
@Enumerated
做用：設置枚舉類型

方式一：

/** 保存字符串到數據庫 */
@Enumerated(EnumType.STRING)
private Role role;
方式二：

/** 保存整數到數據庫 */
@Enumerated(EnumType.ORDINAL)
private Role role;
上面定義的枚舉：Role

/** 角色 */
public enum Role {
遊客, 會員, 管理員
}
使用：
User user = new User();
user.setRole(Role.管理員);
@Transient
做用：修飾的字段不會被持久化

@Transient
private String temp;
這樣也能夠：
private transient String temp;
一對多涉及的註解：

@OneToMany:
做用：創建一對多的關係映射
屬性：
targetEntityClass：指定多的多方的類的字節碼
mappedBy：指定從表實體類中引用主表對象的名稱。
cascade：指定要使用的級聯操做
fetch：指定是否採用延遲加載
orphanRemoval：是否使用孤兒刪除
@ManyToOne
做用：創建多對一的關係
屬性：
targetEntityClass：指定一的一方實體類字節碼
cascade：指定要使用的級聯操做
fetch：指定是否採用延遲加載
optional：關聯是否可選。若是設置爲false，則必須始終存在非空關係。
@JoinColumn
做用：用於定義主鍵字段和外鍵字段的對應關係。
屬性：
name：指定外鍵字段的名稱
referencedColumnName：指定引用主表的主鍵字段名稱
unique：是否惟一。默認值不惟一
nullable：是否容許爲空。默認值容許。
insertable：是否容許插入。默認值容許。
updatable：是否容許更新。默認值容許。
columnDefinition：列的定義信息。
多對多涉及的註解：

@ManyToMany
做用：用於映射多對多關係
屬性：
cascade：配置級聯操做。
fetch：配置是否採用延遲加載。
targetEntity：配置目標的實體類。映射多對多的時候不用寫。
@JoinTable
做用：針對中間表的配置
屬性：
nam：配置中間表的名稱
joinColumns：中間表的外鍵字段關聯當前實體類所對應表的主鍵字段 inverseJoinColumn：中間表的外鍵字段關聯對方表的主鍵字段

@JoinColumn
做用：用於定義主鍵字段和外鍵字段的對應關係。
屬性：
name：指定外鍵字段的名稱
referencedColumnName：指定引用主表的主鍵字段名稱
unique：是否惟一。默認值不惟一
nullable：是否容許爲空。默認值容許。
insertable：是否容許插入。默認值容許。
updatable：是否容許更新。默認值容許。
columnDefinition：列的定義信息。
二、Struts2框架的
@NameSpace

出現的位置：它只能出如今 package 上或者 Action 類上。通常狀況下都是寫在 Action 類上。
做用：指定當前 Action 中全部動做方法的名稱空間。
屬性：
value：指定名稱空間的名稱。寫法和 xml 配置時一致。不指定的話，默認名稱空間是""。
@ParentPackage

出現的位置：它只能出如今 package 上或者 Action 類上。通常狀況下都是寫在 Action 類上。
做用：指定當前動做類所在包的父包。因爲咱們已是在類中配置了，因此無需在指定包名了。
屬性：
value：指定父包的名稱。
@Action

出現的位置：它只能出如今 Action 類上或者動做方法上。通常狀況下都是寫在動做方法上。
做用：指定當前動做方法的動做名稱。也就是 xml 配置時 action 標籤的 name 屬性。
屬性：
value：指定動做名稱。
results[]：它是一個數組，數據類型是註解。用於指定結果視圖。此屬性能夠沒有，當沒有該屬性時，表示不返回任何結果視圖。即便用 response 輸出響應正文。
interceptorRefs[]：它是一個數組，數據類型是註解。用於指定引用的攔截器。
@Result

出現的位置：它能夠出如今動做類上，也能夠出如今 Action 註解中。
做用：出如今類上，表示當前動做類中的全部動做方法均可以用此視圖。出如今 Action 註解中，表示當前 Action 可用此視圖。
屬性：
name：指定邏輯結果視圖名稱。
type：指定前往視圖的方式。例如：請求轉發，重定向，重定向到另外的動做。
location：指定前往的地址。能夠是一個頁面，也能夠是一個動做。
@Results

出現的位置：它能夠出如今動做類上，也能夠出如今 Action 註解中。
做用：用於配置多個結果視圖。
屬性：
value：它是一個數組，數據類型是 result 註解。
@InterceptorRef

出現的位置：它能夠出如今動做類上或者 Action 註解中。
做用：用於配置要引用的攔截器或者攔截器棧
屬性：
value：用於指定攔截器或者攔截器棧

三、Spring框架的
一、IOC的註解
@Component ：建立對象

@Controller

把視圖層類交給Spring管理
@Controller
public class UserAction() {

}
@Service

把業務層類交給Spring管理
@Service
public class UserService() {

}
@Repository

把持久層類交給Spring管理

@Repository
public class UserDao() {

}
@Autowired

根據類型自動注入對象

@Autowired
private UserDao userDao;
@Qualifier

與上面的Autowired一塊兒用，目的根據id獲取對象
//例：把持久化層交給Spring管理，並在業務層經過id注入持久化層對象
@Repository("userDao")
public class UserDao() {}

@Service
public class UserService() {
@Autowired
@Qualifier("userDao")
private UserDao userDao;
}
@Resource

能夠根據類型注入，也能夠根據id裝配，name屬性就是bean的id
@Resource(name="userDao")
private UserDao userDao;
@Value

注入基本類型和字符串類型
@Scope

單例與多例的配置，默認是單例
singleton(單例)；prototype(多例)；request session
//例：Action是多例的，因此應配置對應的屬性，而dao層是單例的，不用配置
@Controller
@Scope(value="prototype")
public class UserAction() {

}

@Repository
public class UserDao() {

}
@Configuration ：

定義配置類，用於替換spring中的xml文件的
@Configuration
public class SpringConfiguration {

}
@ComponentScan：

開啓註解掃描
@Configuration
//@ComponentScan(basePackages={"cn"})
//@ComponentScan(value={"cn"})
@ComponentScan({"cn"})//value:指定掃描的包【推薦，由於能夠不寫】
public class SpringConfiguration {

}
@PropertySource

指定的配置文件
@Configuration
@PropertySource(value="classpath:/config/jdbc.properties")
public class SpringConfiguration {
/**
* 告訴spring框架開啓el表達式
* 在4.3版本之前都須要這個佔位符類
* 在4.3版本以後如下代碼能夠省略不寫
*/
@Bean
public PropertySourcesPlaceholderConfigurer createPSPC(){
return new PropertySourcesPlaceholderConfigurer();
}
}
@Bean

用在方法上面，建立對象的，根據方法的返回類型
@Component
public class JdbcConfig {

@Bean(name="dataSource")//至關於：<bean id="ds" class="com.mchange.v2.c3p0.ComboPooledDataSource" />
public DataSource createDataSource(){
ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
try {
comboPooledDataSource.setDriverClass("com.mysql.jdbc.Driver");
} catch (Exception e) {
e.printStackTrace();
}
comboPooledDataSource.setJdbcUrl("jdbc:mysql://localhost:3306/springIOC");
comboPooledDataSource.setUser("root");
comboPooledDataSource.setPassword("root");
return comboPooledDataSource;
}
@Bean(name="queryRunner")
public QueryRunner createQr(@Qualifier(value="dataSource") DataSource dataSource){
return new QueryRunner(dataSource);
}
}
@Import

導入其餘的配置類,交給Spring管理
1
@Configuration
@Import(value={JdbcConfig.class})
public class SpringConfiguration {
}
二、AOP的經常使用註解
AOP : 全稱是Aspect Oriented Programming 即: 面向切面編程
須要在Spring的主配置文件中添加如下標籤。開啓aop註解的支持
<aop:aspectj-autoproxy/>
@Aspect

做用：把當前類聲明爲切面類。
@Aspect //聲明爲切面類
public class MyLogger {
}
@Before

做用：把當前方法當作是前置通知。
屬性：
value：用於指定切入點表達式，還能夠指定切入點表達式的引用。
@Aspect //聲明爲切面類
public class MyLogger {
//前置通知
@Before("pt1()")
public void beforePrintLog(){
System.out.println("前置通知：打印日誌了......");
}
}
@AfterReturning

做用：把當前方法當作是後置通知。
屬性：
value：用於指定切入點表達式，還能夠指定切入點表達式的引用。
@Aspect //聲明爲切面類
public class MyLogger {
//後置通知
@AfterReturning("pt1()")
public void afterRetunningPrintLog(){
System.out.println("後置通知：打印日誌了......");
}
}
@AfterThrowing

做用：把當前方法當作是異常通知。
屬性：
value：用於指定切入點表達式，還能夠指定切入點表達式的引用。
@Aspect //聲明爲切面類
public class MyLogger {
//異常通知
@AfterThrowing("pt1()")
public void afterThrowingPrintLog(){
System.out.println("異常通知：打印日誌了......");
}
}
@After

做用：把當前方法當作是最終通知。
屬性：
value：用於指定切入點表達式，還能夠指定切入點表達式的引用。
@Aspect //聲明爲切面類
public class MyLogger {
//最終通知
@After("pt1()")
public void afterPrintLog(){
System.out.println("最終通知：打印日誌了......");
}
}
@Around

做用：把當前方法當作是環繞通知。
屬性：
value：用於指定切入點表達式，還能夠指定切入點表達式的引用。
@Pointcut

做用：指定切入點表達式
屬性：
value：指定表達式的內容
/**
* 切入點
*/
@Pointcut("execution(public void cn.service.impl.CustomerServiceImpl.saveCustomer())")
public void pt1(){}
/**
* 環繞通知：
* 是spring提供給咱們的手動控制代碼執行的通知，
* 方法中須要手動控制方法執行
*
* 參數中須要一個接口:Spring注入的，瞭解
* ProcedingJoinPoint
*/
@Around("pt1()")
public Object around(ProceedingJoinPoint pjp){
//System.out.println("最終通知：打印日誌......");
Object[] obj = pjp.getArgs();//參數
//返回值
Object rtValue = null;
//手動調用方法
try {
//前置通知
System.out.println("前：打印日誌");
pjp.proceed(obj);
//後置通知
System.out.println("後：打印日誌");
} catch (Throwable e) {
//異常通知
System.out.println("異：打印日誌");
e.printStackTrace();
}finally{
//最終通知
System.out.println("終：打印日誌");
}
return rtValue;
}
三、事務的註解
@Transactiona

聲明在類上是表示全局事務，聲明在方法上表示局部事務，局部事務會覆蓋全局事務，默認屬性是傳播事務，非只讀
@Transactional(readOnly=true)
public class AccountServiceImpl implements IAccountService {

public Account findAccountById(Integer id) {
return ad.findAccountById(id);
}
}
@EnableTransactionManagement

開啓事務管理器
@Configuration
@EnableTransactionManagement
public class SpringConfiguration {

}

版權聲明：本文爲CSDN博主「I7show」的原創文章
原文連接：https://blog.csdn.net/I7show/article/details/78843417

log4j.properties:

log4j.rootLogger = DEBUG , C , D , E 

### console ###
log4j.appender.C = org.apache.log4j.ConsoleAppender
log4j.appender.C.Target = System.out
log4j.appender.C.layout = org.apache.log4j.PatternLayout
log4j.appender.C.layout.ConversionPattern = [mybatis_study][%p] [%-d{yyyy-MM-dd HH\:mm\:ss}] %C.%M(%L) | %m%n

### log file ###
log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File = ../logs/mybatis_study.log
log4j.appender.D.Append = true
log4j.appender.D.Threshold = INFO 
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = [mybatis_study][%p] [%-d{yyyy-MM-dd HH\:mm\:ss}] %C.%M(%L) | %m%n

### exception ###
log4j.appender.E = org.apache.log4j.DailyRollingFileAppender
log4j.appender.E.File = ../logs/mybatis_study_error.log 
log4j.appender.E.Append = true
log4j.appender.E.Threshold = ERROR 
log4j.appender.E.layout = org.apache.log4j.PatternLayout
log4j.appender.E.layout.ConversionPattern = [mybatis_study][%p] [%-d{yyyy-MM-dd HH\:mm\:ss}] %C.%M(%L) | %m%n

###mybatis show sql###
log4j.logger.com.ibatis=debug
log4j.logger.com.ibatis.common.jdbc.SimpleDataSource=debug
log4j.logger.com.ibatis.common.jdbc.ScriptRunner=debug
log4j.logger.com.ibatis.sqlmap.engine.impl.SqlMapClientDelegate=debug

log4j.logger.java.sql.Connection=debug
log4j.logger.java.sql.Statement=debug
log4j.logger.java.sql.PreparedStatement=debug

spring-hibernate.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd

      http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
      http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd">
    <!-- 導入外部資源文件
system-properties-mode:FALLBACK　　 默認值，不存在時覆蓋
　　　　　　　　　　　　　　NEVER　　　   不覆蓋
　　　　　　　　　　　　　　OVERRIDE　　 覆蓋-->
    <context:property-placeholder location="classpath:jdbc.properties"
                                  system-properties-mode="FALLBACK"/>
    <!-- 自動掃描dao和service包(自動注入) -->
    <context:component-scan base-package="com.hm.dao"/>
    <!-- 使用C3P0數據源，MySQL數據庫 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
          destroy-method="close">
        <!-- MySQL5 -->
        <property name="driverClass" value="${driverClass}"/>
        <property name="jdbcUrl" value="${jdbcUrl}"/>
        <property name="user" value="${user}"/>
        <property name="password" value="${password}"/>
        <property name="maxPoolSize" value="40"/>
        <property name="minPoolSize" value="1"/>
        <property name="initialPoolSize" value="1"/>
        <property name="maxIdleTime" value="20"/>
    </bean>

    <!-- session工廠 -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">

        <!-- 配置數據源 -->
        <property name="dataSource" ref="dataSource"/>

        <!-- 配置Hibernate屬性 -->
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">true</prop>

                <!-- 配置C3P0數據源鏈接池 -->
                <prop key="hibernate.c3p0.max_size">10</prop>
                <prop key="hibernate.c3p0.min_size">5</prop>
                <prop key="hibernate.c3p0.acquire_increment">2</prop>
                <prop key="hibernate.c3p0.idle_test_period">2000</prop>
                <prop key="hibernate.c3p0.timeout">2000</prop>
                <prop key="hibernate.c3p0.max_statements">10</prop>
                <prop key="current_session_context_class">thread</prop>
            </props>
        </property>
        <!-- 掃描POJO文件 -->
        <property name="packagesToScan">
            <list>
                <value>com.hm.vo</value>
            </list>
        </property>
    </bean>

    <!-- 配置事務 -->
    <bean name="txManager"
          class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    <tx:annotation-driven transaction-manager="txManager"/>
</beans>

struts2.xml：分紅多個struts2文件，而後導入一個struts2文件中

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.1//EN" "http://struts.apache.org/dtds/struts-2.1.dtd">
<struts>


<constant name="struts.i18n.encoding" value="UTF-8"></constant>

<constant name="struts.devMode" value="true"></constant>

<constant name="struts.configuration.xml.reload" value="false" />

<package name="page" namespace="/" extends="struts-default">

<action name="bm_*" class="com.jd.bms.sysmannage.action.CrudPageAction"
method="{1}Book">
<result name="getId">/WEB-INF/pages/system/booksystem/Bookmainshow.jsp
</result>
<result name="add">/WEB-INF/pages/system/booksystem/Bookmainadd.jsp
</result>
<result name="input">/WEB-INF/pages/system/error/Bookmainerror.jsp</result>
<result name="update">/WEB-INF/pages/system/booksystem/Bookmainupdate.jsp
</result>
<result name="adds" type="redirect">/bookshow</result>
<result name="Childadds" type="redirect">/bookshowtwo</result>
<result name="Itadds" type="redirect">/bookshowthree</result>
<result name="bankadd">/WEB-INF/pages/system/classification/Bookbankadd.jsp</result>
<result name="bankadds" type="redirect">/bookbank</result>
<result name="addUser">/WEB-INF/pages/system/usersystem/useradd.jsp</result>
<result name="usermainpage" type="redirect">/usermain</result>
</action>

<action name="bookshow" class="com.jd.bms.sysmannage.action.PagingAction"
method="bookshow">
<result name="bookshow">/WEB-INF/pages/system/booksystem/Bookmain.jsp</result>
</action>
<action name="bookshowtwo" class="com.jd.bms.sysmannage.action.PagingAction"
method="bookshowtwo">
<result name="bookshowtwo">/WEB-INF/pages/system/booksystem/Bookmain.jsp</result>
</action>
<action name="bookshowthree" class="com.jd.bms.sysmannage.action.PagingAction"
method="bookshowthree">
<result name="bookshowthree">/WEB-INF/pages/system/booksystem/Bookmain.jsp</result>
</action>

<action name="bookbank" class="com.jd.bms.sysmannage.action.PagingAction" method="bookbank">
<result name="bookbank">/WEB-INF/pages/system/classification/Bookbank.jsp</result>
</action>

<action name="usermain" class="com.jd.bms.sysmannage.action.PagingAction"
method="usermain">
<result name="usermain">/WEB-INF/pages/system/usersystem/usermain.jsp</result>
</action>

<action name="user_page" class="com.jd.bms.sysmannage.action.BmUserAction" method="user_page">
<result name="input">/WEB-INF/pages/system/error/Bookmainerror.jsp</result>
<result name="user_page">/WEB-INF/pages/system/usersystem/usermain.jsp</result>
<result name="usermain_page" type="redirect">/usermain</result>
</action>

<action name="messagex" class="com.jd.bms.sysmannage.action.BmLeaveWordAction" method="messagex">
<result name="messagex">/WEB-INF/pages/system/message/userleavemain.jsp</result>
</action>
<action name="delmess" class="com.jd.bms.sysmannage.action.BmLeaveWordAction" method="delmess">
<result name="delmess" type="redirect">/messagex</result>
</action>

<action name="adminmess" class="com.jd.bms.sysmannage.action.BmAdminAction" method="adminmess">
<result name="admin">/WEB-INF/pages/system/administrator/administrator.jsp</result>
</action>
<action name="amdin_*" class="com.jd.bms.sysmannage.action.BmAdminAction" method="{1}Admin">
<result name="updateAdmin" type="redirect">/adminmess</result>
</action>





<action name="engi" class="com.jd.bms.sysmannage.action.EngiAction"
method="engi">
<result name="toLogin" type="redirect">/toLogin</result>
<result name="regiPage">/registers.jsp</result>
</action>

<action name="toLogin" class="com.jd.bms.sysmannage.action.LoginAction"
method="toLogin">
<result name="toLogin">/login.jsp</result>
</action>

<action name="login" class="com.jd.bms.sysmannage.action.LoginAction"
method="login">
<result name="main" type="redirect">/main</result>
<result name="usermain" type="redirect">/usermain</result>
<result name="loginPage">/login.jsp</result>
</action>
<action name="add_*" class="com.jd.bms.sysmannage.action.BmLeaveWordAction" method="{1}LeaveWord">
<result name="message" type="redirect">/message</result>
</action>

<action name="person" class="com.jd.bms.sysmannage.action.BmUserAction" method="person">
<result name="person">/WEB-INF/pages/forepart/main/personmain.jsp</result>
</action>

<action name="userupdate" class="com.jd.bms.sysmannage.action.BmUserAction" method="userupdate">
<result name="userupdate" type="redirect">/person</result>
<result name="input">/WEB-INF/pages/forepart/main/personmain.jsp</result>
</action>

<action name="pwdmodil" class="com.jd.bms.sysmannage.action.BmUserPwdAction" method="pwdmodil">
<result name="pwd">/WEB-INF/pages/forepart/main/modelfoactionmain.jsp</result>
</action>

<action name="pwdupdate" class="com.jd.bms.sysmannage.action.BmUserPwdAction" method="pwdupdate">
<result name="pwdupdate">/WEB-INF/pages/forepart/main/modelfoactionmain.jsp</result>
<result name="toLogin" type="redirect">/toLogin</result>
</action>

<action name="bookshop" class="com.jd.bms.sysmannage.action.BookshopAction" method="bookshop">
<result name="bookshop">/WEB-INF/pages/forepart/main/bookshopsmain.jsp</result>
</action>

<action name="adds_*" class="com.jd.bms.sysmannage.action.BookshopAction" method="{1}Book">
<result name="libBook" type="redirect">/main</result>
<result name="literyBook" type="redirect">/Literary</result>
<result name="childBook" type="redirect">/Child</result>
<result name="bmitBook" type="redirect">/itbook</result>
</action>


<action name="delBook" class="com.jd.bms.sysmannage.action.BookshopAction" method="delBook">
<result name="delBook" type="redirect">/bookshop</result>
</action>
</package>
</struts>

pom.xml:

<?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.hm</groupId>
    <artifactId>ssh</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>ssh Maven Webapp</name>
    <!-- FIXME change it to the project's website -->
    <url>http://www.example.com</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring.version>4.2.9.RELEASE</spring.version>
        <hibernate.version>5.1.7.Final</hibernate.version>
        <struts2.version>2.3.32</struts2.version>
    </properties>
    <dependencies>
        <!-- C3P0 依賴  注意不能少jar包、核心包有版本控制不低於0.9.5.2 -->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.4</version>
        </dependency>
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>mchange-commons-java</artifactId>
            <version>0.2.15</version>
        </dependency>
        <!--JDK11 JAXB api被認爲是Java EE api,所以再也不包含在Java SE 9默認的類路徑。在Java中11他們徹底從JDK中刪除-->
        <dependency>
            <groupId>javax.xml.bind</groupId>
            <artifactId>jaxb-api</artifactId>
            <version>2.3.0</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.hynnet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <!-- 只在編譯測試時運行 -->
            <scope>provided</scope>
        </dependency>



        <!-- Spring 核心依賴 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Spring web依賴 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- Spring整合ORM框架依賴 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Struts2 核心依賴 -->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-core</artifactId>
            <version>${struts2.version}</version>
        </dependency>
        <!-- Struts2和Spring整合依賴 -->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-spring-plugin</artifactId>
            <version>${struts2.version}</version>
        </dependency>
        <!-- Hibernate 核心依賴 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <!-- MySQL 依賴 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.42</version>
        </dependency>

        <!-- AspectJ依賴 -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.10</version>
        </dependency>
        <!-- SLF4J依賴 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.25</version>
        </dependency>


    </dependencies>
<build>
<finalName>ssh</finalName>
<plugins>
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>2.3.2</version>
        <configuration>
            <source>1.7</source>
            <target>1.7</target>
            <compilerArguments>
                <extdirs>ssh\lib</extdirs>
            </compilerArguments>
        </configuration>
    </plugin>
<!--    <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat8-maven-plugin</artifactId>
        <version>2.2</version>
        <configuration>
            &lt;!&ndash; <url>http://localhost:8080/manager</url> &ndash;&gt;            &lt;!&ndash; tomcat6部署管理路徑 &ndash;&gt;
            <url>http://localhost:8080/manager/text</url>                &lt;!&ndash; tomcat7部署管理路徑 &ndash;&gt;
            <username>admin</username>                                &lt;!&ndash; tomcat的管理員帳號 &ndash;&gt;
            <password>admin</password>
            <port>8081</port>
            <path>/</path>                            &lt;!&ndash; 部署路徑 &ndash;&gt;
            <charset>UTF-8</charset>
            <encoding>UTF-8</encoding>
            &lt;!&ndash; 運行redeploy命令前，要能正常訪問http://localhost:8080/manager &ndash;&gt;
        </configuration>
        <executions>
            <execution>
                <phase>package</phase>
                <goals>
                    <goal>run</goal>
                </goals>
            </execution>
        </executions>
    </plugin>-->
</plugins>
</build>

</project>

session類：

public class MySession {
@Autowired
private SessionFactory sessionFactory;

public void setSessionFactory(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}

protected Session getCurrentSession() {
return this.sessionFactory.getCurrentSession();
}

}

dao層：

@Repository("bmAdminDao")
public class BmAdminDaoImpl extends MySession implements BmAdminDao {

@Override
public List<BmAdmin> getBmAdminLoginName(String loginname) {
List<BmAdmin> list = null;
Query q = this.getCurrentSession()
.createQuery("from BmAdmin where loginName=?")
.setString(0, loginname);
list = q.list();
if (list.size() >= 0 && list != null) {
return list;
}
return null;
}

}

service層：

@Service
@Transactional
public class BmAdminServiceImpl implements BmAdminService {

@Autowired
private BmAdminDao bmAdminDao;

public List<BmAdmin> getBmAdminLoginName(String loginname) {
// TODO Auto-generated method stub
return bmAdminDao.getBmAdminLoginName(loginname);
}

controller層：

public class BmAdminAction extends ActionSupport {
private static final long serialVersionUID = 4297180770984426910L;
@Autowired
private BmAdminService bmAdminService;
private BmAdmin bmAdmin;

public BmAdmin getBmAdmin() {
return bmAdmin;
}

public void setBmAdmin(BmAdmin bmAdmin) {
this.bmAdmin = bmAdmin;
}

public String adminmess() throws Exception {

HttpServletRequest request = ServletActionContext.getRequest();
HttpSession session = request.getSession();
String loginName = (String) session.getAttribute("loginname");
List<BmAdmin> list = bmAdminService.getBmAdminLoginName(loginName);
ActionContext ctx = ActionContext.getContext();
ctx.put("adminme", list);

return "admin";
}

}

vo層：

@Entity
@Table(name = "bm_admin")
public class BmAdmin implements Serializable {

private static final long serialVersionUID = 5938178566540780464L;
@Id
@Column(name = "id")
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer id;
@Column(name = "login_name", length = 100, nullable = false, unique = true)
private String loginName;
@Column(name = "password", length = 32, nullable = false)
private String password;
@Column(name = "name", length = 32, nullable = false, unique = true)
private String name;
@Column(name = "serialnumber", length = 32, nullable = false)
private String serialnumber;
@Column(name = "email", length = 32, nullable = false)
private String email;
@Column(name = "mobile", length = 32, nullable = false)
private String mobile;

public Integer getId() {
return id;
}

public void setId(Integer id) {
this.id = id;
}

public String getLoginName() {
return loginName;
}

public void setLoginName(String loginName) {
this.loginName = loginName;
}

public String getPassword() {
return password;
}

public void setPassword(String password) {
this.password = password;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getSerialnumber() {
return serialnumber;
}

public void setSerialnumber(String serialnumber) {
this.serialnumber = serialnumber;
}

public String getEmail() {
return email;
}

public void setEmail(String email) {
this.email = email;
}

public String getMobile() {
return mobile;
}

public void setMobile(String mobile) {
this.mobile = mobile;
}

@Override
public String toString() {
return "BmAdmin [id=" + id + ", loginName=" + loginName + ", password="
+ password + ", name=" + name + ", serialnumber="
+ serialnumber + ", email=" + email + ", mobile=" + mobile
+ "]";
}

}

SSM項目（spring+springMVC+mybatis）

@Component:通用註解；@Name:通用註解；@Repository:持久化層組件註解

@Service:業務層組件註解；@Controller:控制層組件註解

@Autowired註解標記也能夠用在字段定義或setter方法定義前面，默認按類型匹配注入

@RequestMapping標明這個類或者方法與哪個客戶請求對應

@ResponseBody註解(在Spring MVC中，此註解與JSON響應相關)

@Transactional屬性：能夠做用於接口、接口方法、類以及類方法上。看成用於類上時，該類的全部 public 方法將都具備該類型的事務屬性，同時，咱們也能夠在方法級別使用該標註來覆蓋類級別的定義。

value	String	可選的限定描述符，指定使用的事務管理器
propagation	enum: Propagation	可選的事務傳播行爲設置
isolation	enum: Isolation	可選的事務隔離級別設置
readOnly	boolean	讀寫或只讀事務，默認讀寫
timeout	int (in seconds granularity)	事務超時時間設置
rollbackFor	Class對象數組，必須繼承自Throwable	致使事務回滾的異常類數組
rollbackForClassName	類名數組，必須繼承自Throwable	致使事務回滾的異常類名字數組
noRollbackFor	Class對象數組，必須繼承自Throwable	不會致使事務回滾的異常類數組
noRollbackForClassName	類名數組，必須繼承自Throwable	不會致使事務回滾的異常類名字數組

@Qualifier：Qualifier的意思是合格者，經過這個標示，代表了哪一個實現類纔是咱們所須要的，添加@Qualifier註解，須要注意的是@Qualifier的參數名稱爲咱們以前定義@Service註解的名稱之一。

@resource注入時比較簡單了註解自帶了「name」的val就是@Service註解的名稱之一

@RequestParam：Spring會自動將表單參數注入到方法參數(名稱一致)

@ModelAttribute：當Controller組件處理後，須要向JSP傳值用此方法

@ExceptionHandler註解提供了Spring MVC處理異常的方法

AOP切面編程通知：

spring aop的5種通知類型都有

Before前置通知

AfterReturning後置通知

Around環繞通知

AfterThrowing異常通知

After最終通知

@PathVariable做用是將URI請求模板中的變量解析出來，映射處處理方法的參數上

@RequestMapping(value = "/emp/{id}",method = requestMethod.GET)

public String execute(@PathVariable("id") int id){

　　//查詢操做處理

　　return " ";

}

SpringMVC中對數據在傳輸過程當中的result風格處理方式：

@RequestMapping(value="book",method=RequestMethod.POST) //添加

@RequestMapping(value="book",method=RequestMethod.DELETE)//刪除

@ResponseBody

利用AJAX發送請求

@RequestMapping(value="book",method=RequestMethod.PUT).//修改

利用Ajax,在客戶端發出PUT、DELETE動做的請求

在form請求中：

在web.xml配置過濾器：

HiddenHttpMethodFilter
org.springframework.web.filter.HiddenHttpMethodFilter

<input type="hidden" name="_method" value="PUT"/>

@RequestMapping(value="book",method=RequestMethod.GET)//查詢

一、項目結構

二、配置文件：

applicationContext.xml

<!--掃描spring註解管理的類-->
<context:component-scan base-package="com.exp.service"/>
<!--加載數據庫配置文件-->
<context:property-placeholder location="classpath:jdbc.properties" />

<!--配置數據源-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="${driver}"/>
    <property name="url" value="${url}"/>
    <property name="username" value="${username}"/>
    <property name="password" value="${password}"/>
</bean>

<!-- 註冊事務管理器 -->
<bean id="msg" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
</bean>

<!-- 開啓事務註解驅動 -->
<tx:annotation-driven transaction-manager="msg" />


<!-- 配置mybatis的sqlSessionFactory -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <property name="mapperLocations" value="classpath:com/exp/mapping/*.xml"/>
    <property name="configLocation" value="classpath:spring-mybatis.xml"/>//這個配置文件只能配置別名、緩存等特性，不能在該配置文件掃描mapper.xml文件
</bean>

<!-- 配置能夠總體掃描MapperDao的一個掃描器 -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.exp.mapping"/>
    <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
</bean>

jdbc.properties:

driver =com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/login?useUnicode=true&characterEncoding=utf8
username=root
password=root

mybatis-config.xml:


<settings>
    <!-- 是否開啓自動駝峯命名規則create_time createTime,默認是false -->
    <setting name="mapUnderscoreToCamelCase" value="true"/>
    <!--開啓延遲加載的總開關 -->
    <setting name="lazyLoadingEnabled" value="true" />
    <!--開啓按需加載的開關 -->
    <setting name="aggressiveLazyLoading" value="false" />
    <!--開啓二級緩存 -->
    <!-- <setting name="cacheEnabled" value="true" /> -->
</settings>


<typeAliases>
    <!-- 批量設置別名 -->
    <package name="com.exp.vo" />
</typeAliases>


spring-mvc.xml:

<!-- 掃描controller -->
<context:component-scan base-package="com.exp.controller" />
<!--處理靜態資源-->
<mvc:resources mapping="/*" location="/static/" />
<!-- 生成註解映射器和適配器 -->
<mvc:annotation-driven></mvc:annotation-driven>
<!-- ViewResolver視圖解析器，解析jsp視圖 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <!-- 指定視圖路徑前綴 -->
    <property name="prefix" value="/WEB-INF/jsp"/>
    <!-- 指定視圖路徑後綴 -->
    <property name="suffix" value=".jsp"/>
</bean>

web.xml

<display-name>ssm</display-name>
<!--spring容器加載-->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
</context-param>
<!--字符過濾器-->
<filter>
    <filter-name>encodeFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>UTF-8</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>encodeFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>
<!--在建立serveContext時候加載spring容器-->
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<!--springMVC中央控制器配置-->
<servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-mvc.xml</param-value>
    </init-param>
</servlet>
<servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>
<!--數據源監控-->
<servlet>
    <servlet-name>DruidStatView</servlet-name>
    <servlet-class>com.alibaba.druid.support.http.StatViewServlet</servlet-class>
</servlet>

<servlet-mapping>
    <servlet-name>DruidStatView</servlet-name>
    <url-pattern>/druid/*</url-pattern>
</servlet-mapping>
<!--首頁-->
<welcome-file-list>
    <welcome-file>login.jsp</welcome-file>
</welcome-file-list>

controller層：

@Controller
public class loginController {
    @RequestMapping("/")
    public String loginPage() {
        return "login";
    }
}

service層：

@Override
@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT)
public void funttwosfer(int formUserId, int id, BigDecimal money) {
System.out.println("進入轉帳");
BigDecimal formmoney = fundao.getMoney(formUserId);
if (!(formmoney.compareTo(money) == -1)) {
// 轉出帳戶減掉金額
fundao.subMoney(formUserId, money);
// int i = 10 / 0;// 測試異常
// 收到帳戶添加金額
fundao.addMoney(id, money);
}
System.out.println("結束轉帳");
}

dao層：

Mapper配置文件中的sql動態編寫，可根據mybatis文檔中的各類關鍵字一一對應實現：

測試類：

類註解：

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration(locations = {"classpath:applicationContext.xml"})

具體測試

@Resource

private UserService userService;

@Test
public void demo1(){
UserBaseInfo userBaseInfo=userService.getUserBaseInfo(1);
System.out.println("我要輸出內容了");
System.out.println(userBaseInfo.getUserName());
System.out.println("haha");

}

pom.xml相關信息：

modelVersion	Maven模塊版本，目前咱們通常都取值4.0.0
groupId	整個系統的名稱。
artifactId	子模塊名稱。
packaging	打包類型，可取值：jar,war等等，這個配置用於package的phase，具體能夠參見package運行的時候啓動的plugin，後面有機會咱們會講述如何配置打包的插件。

<modelVersion>4.0.0</modelVersion><!---->
<groupId>com.exp</groupId>
<artifactId>learn</artifactId>
<packaging>war</packaging><!--jar樣式-->
<version>1.0-SNAPSHOT</version><!--項目版本控制-->
<name>learn Maven Webapp</name>
<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><!--編碼格式-->
    <spring.version>4.2.9.RELEASE</spring.version><!--springjar包版本-->
    <jackson.version>2.5.0</jackson.version><!--json版本-->
</properties>
<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
    <!-- spring -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>${spring.version}</version>
        <scope>test</scope>
    </dependency>
    <!-- mybatis 包 -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.2.8</version>
    </dependency>
    <!--mybatis spring 插件 -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>1.2.2</version>
    </dependency>
    <!-- mysql鏈接 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.6</version>
    </dependency>
    <!-- 數據源 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.0.12</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.4</version>
    </dependency>
    <!-- log4j -->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>
    <!-- servlet -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>servlet-api</artifactId>
        <version>3.0-alpha-1</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>
    <!-- json -->
    <dependency>
        <groupId>org.codehaus.jackson</groupId>
        <artifactId>jackson-mapper-asl</artifactId>
        <version>1.9.13</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.3</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-annotations</artifactId>
        <version>${jackson.version}</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-core</artifactId>
        <version>${jackson.version}</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>${jackson.version}</version>
    </dependency>
    <!-- 文件上傳 -->
    <dependency>
        <groupId>commons-io</groupId>
        <artifactId>commons-io</artifactId>
        <version>2.4</version>
    </dependency>
    <dependency>
        <groupId>commons-fileupload</groupId>
        <artifactId>commons-fileupload</artifactId>
        <version>1.2.2</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>3.8.1</version>
        <scope>test</scope>
    </dependency>
    <!--分頁插件-->
    <dependency>
        <groupId>com.github.pagehelper</groupId>
        <artifactId>pagehelper</artifactId>
        <version>5.1.8</version>
    </dependency>
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus</artifactId>
        <version>3.0.5</version>
    </dependency>

</dependencies>
<build>
    <finalName>learn</finalName>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.5.1</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
            </configuration>
        </plugin>
    </plugins>
</build>

經過將應用多模塊拓展，水平擴展相應的組件，來知足當前的需求

Maven多模塊項目

一、公共模塊（編碼過程當中須要重複用到的工具，減小繁雜度）

二、數據處理模塊（各類條件下的增刪查改等，有利於服務層的重複利用）

三、服務層模塊（具體邏輯的處理與編寫，在一二的基礎上更加駕輕就熟）

四、控制層模塊（用於數據處理以個性的方式與前臺交互渲染）

SOA（面向服務的架構)-------》ESB架構（企業服務總線）

場景：更多的傳統企業

提供多系統集成更廉價的解決方案

esb：

傳統中間件技術與XML、Web服務等技術結合

soa：

將應用程序的不一樣功能單元（稱爲服務）進行拆分，並經過這些服務之間定義良好的接口和契約聯繫起來

嵌入式編程、約定大於配置、組件化開發、微服務開發、針對開發與業務爲主、是web服務精簡版

SpringBoot項目

搭建項目：new-->Project-->Spring Initralizr

pom文件：

<modelVersion>4.0.0</modelVersion>
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.9.RELEASE</version>

    <relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.hm</groupId>
<artifactId>springbootdemo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>war</packaging>
<name>springbootdemo</name>
<description>Demo project for Spring Boot</description>

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <java.version>1.8</java.version>
</properties>

<dependencies>
    <!--引用thymeleaf模板-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
    <!--引入web相關jar包-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--mysql驅動包-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-tomcat</artifactId>
        <scope>provided</scope>
    </dependency>
    <!--springboot測試包-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <!--引入支持jsp的jar包-->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.tomcat.embed</groupId>
        <artifactId>tomcat-embed-jasper</artifactId>
    </dependency>
    <!--mybatis-->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.2</version>
    </dependency>
    <!--熱部署-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <optional>true</optional>
    </dependency>
    <!--log4j-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-log4j</artifactId>
        <version>unknown</version>
    </dependency>
</dependencies>

<build>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.xml</include>
            </includes>
        </resource>
    </resources>
    <!--打包插件-->
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

application.properties文件：（可用yml文件替換）

server.port=8080
#日誌打印
logging.level.org.springframework=debug
logging.level.org.mybatis=debug
logging.level.org.apache.ibatis=debug
#數據庫鏈接
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql:/localhost:3306/yhm?useUnicode=true&useSSL=true
spring.datasource.username=root
spring.datasource.password=root

#SpringMVC相關頁面解析器配置
spring.mvc.view.prefix=/WEB-INF/jsp/
spring.mvc.view.suffix=.jsp


#mapper文件掃描
mybatis.mapper-locations=classpath*:com/hm/springbootdemo/dao/*.xml
mybatis.type-aliases=com.hm.springbootdemo.vo

dao層：

@Mapper
@Repository("userLoginValidate")
public interface UserLoginValidate {
            public boolean login(@Param("account")String account,@Param("password") String password);
}
mapper配置文件

<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.hm.springbootdemo.dao.UserLoginValidate">
    <select id="login" resultType="boolean">
        select * from Uuser where user_name=#{userName} and user_password=#{userPassword}
    </select>
</mapper>


service層：

public interface UserService {
    public boolean login(String account,  String password);
}

@Service("userService")
public class UserServiceImpl implements UserService {
    @Autowired
    private UserLoginValidate userLoginValidate;
    @Override
    public boolean login(String account, String password) {
        boolean login = userLoginValidate.login(account, password);
        if (login==true){
            return true;
        }
        return false;
    }
}

controller層：

@RequestMapping("/login")
public String requestMainPage(@Param("account")String account,@Param("passwoud") String password){

    if (account!=null||password!=null){
        boolean login = userService.login(account, password);
        if(login==true){
            return "main";
        }
        return "index";
    }
    return "index";
}

提供良好的開箱即用經驗的典型用例和可擴展性機制覆蓋。

springColud

場景：大型互聯網企業

項目搭建：

填寫包名--項目名--打包樣式：

暫時不選擇模板依賴：

注意項目名與項目所放路徑

Springcolud微服務初始構架：

IDEAmaven設置地址：

maven的初始化文件：（項目開發能夠本身另行添加）

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.9.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>springcolud</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springcolud</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

設置項目須要隱藏的文件

建立子模塊

能夠將父級模塊中的文件刪除，留下pom文件做爲父級通用依賴管理者

父級pom.xml文件：

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <modules>
        <module>spring-colud-ms-eureka</module>
    </modules>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.9.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>


    <groupId>com.example</groupId>
    <artifactId>springcolud</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springcolud</name>
    <!--最後打包 最外層的pom 須要更改成 pom而不是jar-->
    <packaging>pom</packaging>
    <description>Demo project for Spring Colud</description>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-cloud.version>2.0.0.RELEASE</spring-cloud.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--加入springcolud依賴-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter</artifactId>
            <version>${spring-cloud.version}</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

子級pom文件：

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>spring-colud-ms-eureka</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring-colud-ms-eureka</name>
    <packaging>jar</packaging>
    <description>eureka for project</description>


    <parent>
        <groupId>com.example</groupId>
        <artifactId>springcolud</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>



    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
       <!-- <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

在本地配置hosts文件

在啓動器上加入服務註冊註解

@EnableDiscoveryClient

@EnableDiscoveryServer

@EnableEurekaServer：對應的版本問題：（待學習）

springcolud子模塊構架

application.properties文件

#聲明本服務在註冊中心展現的名字、也是在網關訪問時定位服務的名字
spring.application.name=spring-cloud-ms-eureka

#在windows下的hosts文件中增長了  127.0.0.1  swapping1
eureka.instance.hostname=swapping1
server.port=8000

#是否將本身做爲服務註冊到註冊中心，默認爲true，false不能將本身註冊到本身,
#若是有多個服務註冊中心的微服務的話，能夠將這個設置爲true，表示能夠將註冊中心1註冊到註冊中心2中
eureka.client.register-with-eureka=false
#表示是否從eureka註冊中心中獲取註冊信息,默認爲true
eureka.client.fetch-registry=false
#註冊中心的交互地址，設置多個地址能夠用,分隔  查詢服務和註冊服務都須要依賴這個地址
#關於設置註冊中心這麼關鍵的服務，若是是單點話，遇到故障就是毀滅性的。
#在一個分佈式系統中，服務註冊中心是最重要的基礎部分，理應隨時處於能夠提供服務的狀態。爲了維持其可用性，使用集羣是很好的解決方案
#因此 在一個分佈式系統中，設置最少兩個服務註冊中心是最基本的
eureka.client.serviceUrl.defaultZone=http://${eureka.instance.hostname}:${server.port}/eureka/

注意每個端口對應一個服務