IDEA快速搭建WEB项目【记录篇】

这里用的都是市面上通用的技术，而每个公司都有自己的调用方式，可以根据实际情况与业务场景不同去进行变通

 

三层架构：

 界面层（User Interface layer）、业务逻辑层（Business Logic Layer）、数据访问层（Data access layer）。区分层次的目的即为了“高内聚低耦合”的思想。

 

Servlet项目

1、静态资源需要放在WebContent文件下，不应该在web-inf文件下

一：项目结构：

 

 二：底层数据连接：

/**
* 数据库连接
* @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){

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();
}
}
}
}

数据处理使用工厂方式：增强通用性，会牺牲点性能

案列：

@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;
}

三：数据业务处理：

四：前后台数据交互：

 MVC设计：

小型架构目录

├──pom.xml
├──main
| ├──java
| | └──com
| | └──web
| | ├── core
| | | ├── controller //控制器包
| | | ├── entity //POJO包
| | | ├── mapper //Mapper接口包
| | | ├── service //Service接口包
| | | └── serviceImpl //service实现类包
| | └──util //工具包
| ├── resources //资源文件夹（配置文件）
| | ├──applicationContext.xml //Spring配置文件
| | ├──dbconfig.properties //数据库配置文件
| | ├──log4j.properties //log4j配置文件
| | ├──mybatis-config.xml //mybatis配置文件
| | ├──spring-mvc.xml //springMvc配置文件
| | ├──spring-mybatis.xml //spring-mybatis整合配置
| | └── mapping //mapper.xml文件夹
| | └── StudentMapper.xml
| └── webapp ///web应用部署根目录
| ├──login.html //登录页
| ├──pages //jsp文件将爱
| | └── studentList.jsp
| ├──static //静态资源文件夹
| | ├──css
| | | └── login.css
| | ├──images
| | | ├──login-img.png
| | | └── login_logo.png
| | └── js
| | └── JQuery.js
| └── WEB-INF //
| └── web.xml
└──test
├── java
├── resources

 

SSH项目（spring+struts+hibernate）

常用注解：

1、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：列的定义信息。
2、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： 用于指定拦截器或者拦截器栈

3、Spring框架的
1、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 {
}
2、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;
}
3、事务的注解
@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>
<!-- 系统登录的struts配置 -->
<!--设置项目默认的编码方式 -->
<constant name="struts.i18n.encoding" value="UTF-8"></constant>
<!--当出现错误是，出现更多的错误提示 -->
<constant name="struts.devMode" value="true"></constant>
<!-- 当struts.xml改动后，是否重新加载。默认值为false(生产环境下使用),开发阶段最好打开 -->
<constant name="struts.configuration.xml.reload" value="false" />
<!--后台系统 -->
<package name="page" namespace="/" extends="struts-default">

<!--用户和图书的curd -->
<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="userBokk" class="" method="userBokk">
<result name="userBokk"></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>sshlib</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"/>

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

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

1、项目结构

 

 2、配置文件：

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多模块项目

 1、公共模块（编码过程中需要重复用到的工具，减少繁杂度）

2、数据处理模块（各种条件下的增删查改等，有利于服务层的重复利用）

3、服务层模块（具体逻辑的处理与编写，在一二的基础上更加得心应手）

4、控制层模块（用于数据处理以个性的方式与前台交互渲染）

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/

注意每一个端口对应一个服务

单体架构

技术选型非常灵活，优先满足快速上线的要求

 垂直架构

将系统分为不同的层级，每个层级有对应的职责

服务性架构

服务内部高内聚，服务之间低耦合

 

微服务架构

强调每个服务都有单独的运行空间

学着把生活的苦酒当成饮料一样慢慢品尝， 不论生命经过多少委屈和艰辛， 我们总是以一个朝气蓬勃的面孔， 醒来在每一个早上。
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/yhm9/p/11424246.html