Maven（二）

最新推荐文章于 2024-07-25 20:14:43 发布
最新推荐文章于 2024-07-25 20:14:43 发布
阅读量213 收藏
点赞数 1
分类专栏： Maven

一、maven父工程与子模块的拆分与聚合原理

　　　　　　问题描述：将ssh工程拆分为多个模块开发

　　　　　　1.1、拆分原理

　　　　　　　　创建一个maven project(pom)，然后在创建三个子模块(maven moudule)，其中三个子模块，分别为 dao、service、web，也就是将三层的内容分别独立为一个项目，进一步将耦合性降低，其中如何将他们连接起来了，看下图。

　　　　　　　　　　　　　　　　　　

　　　　　　　　为什么需要创建parent父工程来管理其下三个子模块呢？并让其子模块继承他呢？

　　　　　　　　　　继承是为了消除重复，如果将dao、service、web分开创建独立的工程则每个工程的pom.xml文件中的内容存在重复，比如：设置编译版本、锁定spring的版本的等，可以将这些重复的配置提取出来在父工程的pom.xml中定义

　　　　　　　　将三层都独立分开来了，web层如何调用service层代码？service层又如何调用dao层的代码呢？

　　　　　　　　　　这个在没有maven之前是不可以这样做的，但是有了maven一切都不一样了，web层调用service层的代码其实很简单，因为service是一个完整的项目，那么我们在web层这个项目中想要使用别得项目中的代码，只需要通过maven的pom.xml文件编写对应的坐标，将其jar包加入进来即可达到目的，因此，看图中，ssh-web依赖ssh-service，ssh-service依赖ssh-dao，其中的原理就是我说的这样，所以才能将这三层分开成独立的项目，并且进一步抽取其公有依赖的jar包，统一交由父工程来管理，这就maven带来的效果。

 

　　　　　　1.2、聚合原理

　　　　　　　　项目开发通常是分组分模块开发，每个模块开发完成要运行整个工程需要将每个模块聚合在一起运行，比如：dao、service、web三个工程最终会打一个独立的war运行

　　　　　　

二、案例实现

　　　　　　问题描述：使用maven将ssh项目进行分模块，并且实现从web到dao层的数据的存取进行实验

　　　　　　2.1、创建maven-parent父模块

　　　　　　　　　　　　　　　　　　

　　　　　　　　点击next

　　　　　　　　　　　　　　　　　　

　　　　　　　　点击next

　　　　　　　　　　　　　　　　　　

　　　　　　　　创建好之后的父工程如图　　

　　　　　　　　　　　　　　

　　　　　　　　从它的目录结构可以看出，父工程本身不写代码，它里面有一个pom.xml文件，这个文件可以将多个子模块中通用的jar所对应的坐标，集中在父工程中配置，将来的子模块就可以不需要在pom.xml中配置通用jar的坐标le、

 

　　　　　　　　在父工程的pom.xml中抽取一些重复的配置的，比如：锁定jar包的版本、设置编译版本等，一般这种都不需要我们自己临时配置，网上或者公司都有已经写好了的，每次使用就直接丢过来即可。下面给一个我收藏的额。嘿嘿

maven父工程整合ssh通用的pom.xml配置

<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.wuhao.sshtest</groupId>
  <artifactId>ssh_parent</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>pom</packaging>

  
  <!-- 为了确定每个框架的版本号 -->

  <!-- 锁定版本 -->
      <properties>
         <spring.version>4.2.4.RELEASE</spring.version>
        <struts2.version>2.3.24</struts2.version>
        <hibernate.version>5.0.7.Final</hibernate.version>
        <slf4j.version>1.6.6</slf4j.version>
        <log4j.version>1.2.12</log4j.version>
        <shiro.version>1.2.3</shiro.version>
        <cxf.version>3.0.1</cxf.version>
        <c3p0.version>0.9.1.2</c3p0.version> 
        <mysql.version>5.1.6</mysql.version>
    </properties>
      <!-- 锁定版本，struts2-2.3.24、spring4.2.4、hibernate5.0.7 -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aspects</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-orm</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-web</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate</groupId>
                <artifactId>hibernate-core</artifactId>
                <version>${hibernate.version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.struts</groupId>
                <artifactId>struts2-core</artifactId>
                <version>${struts2.version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.struts</groupId>
                <artifactId>struts2-spring-plugin</artifactId>
                <version>${struts2.version}</version>
            </dependency>

        </dependencies>
    </dependencyManagement>
  
  <dependencies>
      <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.4</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.1.37</version>
        </dependency>
        <dependency>
            <groupId>commons-beanutils</groupId>
            <artifactId>commons-beanutils</artifactId>
            <version>1.9.1</version>
        </dependency>
        <!-- <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.2.1</version>
        </dependency> -->
        <dependency>
          <groupId>commons-fileupload</groupId>
          <artifactId>commons-fileupload</artifactId>
          <version>1.3.1</version>
        </dependency>
    
        <!-- jstl -->
         <dependency>
          <groupId>jstl</groupId>
          <artifactId>jstl</artifactId>
          <version>1.2</version>
        </dependency>
        
        <!-- shiro -->
         <!-- apache shiro dependencies -->
         <!-- <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-all</artifactId>
            <version>${shiro.version}</version>
         </dependency> -->

      
       <!-- spring -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.8</version>
        </dependency>
        
         <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</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-context-support</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-orm</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-core</artifactId>
          <version>${spring.version}</version>
        </dependency>
        
    
        
        <!-- struts2  begin -->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-core</artifactId>
            <version>${struts2.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>javassist</artifactId>
                    <groupId>javassist</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-spring-plugin</artifactId>
            <version>${struts2.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-json-plugin</artifactId>
            <version>${struts2.version}</version>
        </dependency>
        <dependency>
              <groupId>org.apache.struts</groupId>
              <artifactId>struts2-convention-plugin</artifactId>
              <version>${struts2.version}</version>
          </dependency>
        <!-- struts2  end -->
        
        <!-- hibernate begin -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>5.2.1.Final</version>
        </dependency>
        <!-- hibernate end -->
        
        <dependency>
              <groupId>c3p0</groupId>
              <artifactId>c3p0</artifactId>
              <version>${c3p0.version}</version>
          </dependency>
        
        <!-- <dependency> 
            <groupId>org.apache.cxf</groupId> 
            <artifactId>cxf-rt-frontend-jaxws</artifactId> 
            <version>${cxf.version}</version> 
        </dependency> 
        <dependency> 
            <groupId>org.apache.cxf</groupId> 
            <artifactId>cxf-rt-transports-http</artifactId> 
            <version>${cxf.version}</version> 
        </dependency> -->
        
        <!-- log start -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <!-- log end -->
        
        <!-- Javamail -->
    <!--     <dependency>
          <groupId>javax.mail</groupId>
          <artifactId>mail</artifactId>
          <version>1.4.4</version>
        </dependency> -->
        
        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
        </dependency>
    
        <dependency>
            <groupId>org.codehaus.xfire</groupId>
            <artifactId>xfire-core</artifactId>
            <version>1.2.6</version>
        </dependency> 
        
        <dependency>
           <groupId>dom4j</groupId>
           <artifactId>dom4j</artifactId>
           <version>1.6</version>
        </dependency>
    
        <!-- <dependency> 
            <groupId>org.apache.poi</groupId> 
            <artifactId>poi</artifactId> 
            <version>3.11</version> 
        </dependency>
        <dependency> 
            <groupId>org.apache.poi</groupId> 
            <artifactId>poi-ooxml</artifactId> 
            <version>3.11</version> 
        </dependency>
        <dependency> 
            <groupId>org.apache.poi</groupId> 
            <artifactId>poi-ooxml-schemas</artifactId> 
            <version>3.11</version> 
        </dependency> -->
    
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>3.8.1</version>
          <scope>test</scope>
        </dependency>
       
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
       <!--  <dependency>
            <groupId>com.oracle</groupId>
            <artifactId>ojdbc14</artifactId>
            <version>10.2.0.4.0</version>
        </dependency> -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>net.sf.ehcache</groupId>
            <artifactId>ehcache-core</artifactId>
            <version>2.6.6</version>
        </dependency>
  </dependencies>
  
   <build>
     <finalName>sshtest</finalName>
    <pluginManagement>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.2</version>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                    <encoding>UTF-8</encoding>
                    <showWarnings>true</showWarnings>
                </configuration>
            </plugin>
        </plugins>
    </pluginManagement>
  </build>
  
</project>

　　　　　　2.2、创建maven-dao子模块

　　　　　　　　　　　　　　

　　　　　　　　点next进入如下图

　　　　　　　　　　　　　　　　　　　

　　　　　　　　点击next，如下图

　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　　　　　　　

　　　　　　　　点击finish，完成，查看父工程中的pom.xml文件

　　　　　　　　　　　　　　

　　　　　　　　查看ssh_dao中的pom.xml文件，会发现多了一个 parent结点，并且内部所包含的结点，其实就是父工程的坐标

　　　　　　　　　　　　　　

 

　　　　　　　　查看ssh_dao的目录结构

　　　　　　　　　　　　　　

　　　　　　　　因为是在dao层，和数据库打交道，那么就在这个项目中，需要配置hibernate.hbm.xml和hibernate.cfg.xml，但是又集成了spring，所以hibernate.cfg.xml就不需要了，添加applicationContext.xml即可(这里需要有spring整合hibernate的基础)

　　　　　　　　　　　　　　　　

　　　　　　　　注意：将applicationContext.xml拆分出一个applicationContext-dao.xml，此文件中只配置dao

applicationContext-dao.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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                              http://www.springframework.org/schema/beans/spring-beans.xsd
                              http://www.springframework.org/schema/tx 
                              http://www.springframework.org/schema/tx/spring-tx.xsd
                              http://www.springframework.org/schema/aop 
                              http://www.springframework.org/schema/aop/spring-aop.xsd
                              http://www.springframework.org/schema/context 
                              http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 1 加载properties文件 -->
    <context:property-placeholder location="classpath:jdbcinfo.properties"/>
    <!-- 2 配置数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driverClass}"></property>
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
        <property name="user" value="${jdbc.user}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    <!-- 3 配置hibernate SessionFactory 注意：这里使用的是hibernate5，要看你使用的jar包是什么版本的，每个人不一样。-->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <!-- 3.1 配置数据源 
            * <property name="属性名" ref="另一个bean引用">
                name 必须是对象的setter方法推断获得，setDataSource(...)， 去掉set DataSource ，首字母小写  dataSource
            * ref 其他bean引用 <bean id=""> 可以任意，一般情况与上面属性名称相同。
        -->
        <property name="dataSource" ref="dataSource"></property>
        <!-- 3.2 配置hibernate其他属性 
            * 在hibernate.cfg.xml 配置文件 “hibernate.dialect” 和 “dialect” 等效的
            * 在spring配置文件中，必须使用“hibernate.dialect”
        -->
        <property name="hibernateProperties">
            <props>
                <!-- 方言 -->
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>
                <!-- 显示sql语句 -->
                <prop key="hibernate.show_sql">true</prop>
                <!-- 格式化sql语句 -->
                <prop key="hibernate.format_sql">true</prop>
            </props>
        </property>
        <!-- 3.3 加载映射文件 
            com/wuhao/ssh_dao/Student/domain/Student.hbm.xml
            com/wuhao/ssh_dao/xxx/domain/xxx.hbm.xml
            com/wuhao/ssh_dao/*/domain/*.hbm.xml
            <property name="mappingLocations" value="classpath:com/wuhao/ssh_dao/domain/*.hbm.xml"></property>
        -->
         <property name="mappingLocations" value="classpath:com/wuhao/ssh_dao/domain/Student.hbm.xml"></property> 
    </bean>
    

     <!-- hibernate中通过sessionFactory创建得session对对象进行操作，spring提供一个hibernateTemplate进行操作，跟spring中的jdbcTemplate一样，
     继承HibernateDaoSupport后，注入SessionFactory即可，在dao层就不用在写hibernateTemplate的set方法了。
        -->
    <bean id="studentDao" class="com.wuhao.ssh_dao.dao.impl.StudentDaoImpl">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
    
</beans>

 jdbcinfo.properties

jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql://localhost:3306/test
jdbc.user=root
jdbc.password=root

　　　　　　　　其他几个Student.java这些就不用看了，太简单了。

 

　　　　　　　　StudentTest.java这个需要讲解一下，因为这里使用junit测试的时候，会报错，报的错误是找不到junit的jar包，这里我们就会很疑惑，为什么会找不到该jar包呢，不是在父工程里面都导入了junit的jar包了吗？这里出错的原因是传递依赖的范围问题。

　　　　　　　　将父工程看做A项目(下面简称A)，将该子模块ssh_dao看做B项目(下面简称B)，A依赖junit的jar包是直接依赖。B继承A（实际操作就是B中填写A的坐标）也可以看成一种依赖，那么就是这样一种关系，B 依赖 A 依赖 junit， A依赖junit是直接依赖没错，那么B跟junit的关系就叫做传递(间接)依赖，我们知道A依赖的junit时，junit的jar包可以设置在A中的使用范围，就是scope属性，可以为compile，test等，而junit设置的是test，只在A中测试的时候用，那么B想用junit时，junit的作用范围是不是也是test呢？这就有一种关系。具体看表。

　　　　　　　　　　　　　　　　

　　　　　　　　　按照刚才上面的例子，来看看在B中，junit的作用范围是什么？首先看B 依赖 A，直接依赖，并且A在B中的作用范围是compile(没设置就默认)，所以在直接依赖这一列中找到compile这一行，也就是用红色框框框起来的一行，然后B 依赖 junit，对A来说，A 是传递依赖 junit，这时候看junit设置的作用范围是多少(也就是看junit在B中的使用范围是什么)？看传递依赖这一行，junit设置的是test，找到test这一列，看相交的地方，是空的，则说明，junti在B中的test范围不能够使用，其实看图，B中任何范围内都不能够使用junit，这样你就理解了这张图是什么意思。这只是原理，实际上我们解决这种问题的时候，用一个简单粗暴的解决方案。什么jar包丢失了，我们就再次导入一次jar包即可。

　　　　　　　　　 所以在ssh_dao子模块的pom.xml中有junit的坐标才能使用test

　　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

　　　　　　　　

　　　　　　2.3、创建ssh_service子模块

　　　　　　　　　　方法同ssh_dao模块创建方法一样，模块名称为ssh_service。

　　　　　　　　　　看ssh_service和ssh_parent的pom.xml文件，会出现和ssh_dao创建时一样的情况，ssh_service多出一个parents结点，ssh_parent多个一个module结点

　　　　　　　　　　　　　　　　

 

　　　　　　　　　　在ssh_service的pom.xml中添加两个依赖

　　　　　　　　　　　　　　　　

 

　　　　　　　　　　　然后编写service层的代码，

　　　　　　　　　　　　　　　　　　　　

　　　　　　　　　　　主要关注一下applicationContext-service.xml中的事务的相关代码

applicationContext-service.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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                              http://www.springframework.org/schema/beans/spring-beans.xsd
                              http://www.springframework.org/schema/tx 
                              http://www.springframework.org/schema/tx/spring-tx.xsd
                              http://www.springframework.org/schema/aop 
                              http://www.springframework.org/schema/aop/spring-aop.xsd
                              http://www.springframework.org/schema/context 
                              http://www.springframework.org/schema/context/spring-context.xsd">
        <!-- 事务管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
    <!--  事务通知 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="save*" propagation="REQUIRED"/>
            <tx:method name="insert*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
            
            <tx:method name="get*" read-only="true"/>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>
    <!-- aop -->
    <aop:config>
        <aop:pointcut id="pointcut" expression="execution(* cn.wuhao.ssh_service.service.impl.*.*(..))" />
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut" />
    </aop:config>

         <!-- 在StudentService中注入StudentDao -->
         <bean id="studentService" class="com.wuhao.ssh_service.service.impl.StudentServiceImpl">
             <property name="studentDao" ref="studentDao"></property>
         </bean>                   
                              
</beans>

 

　　　　　　　　　　　　该层的测试，需要将ssh_dao中的applicationContext-dao.xml将ssh_service的applicationContext-service.xml包含进去才能够实验的通。这里不做测试，

 

 

　　　　　　2.4、创建ssh_web子模块

　　　　　　　　　　方法同maven-dao模块创建方法，模块名称为ssh-web，注意：打包方式为war，而不再是jar包了，因为该层需要放到tomcat中去。与浏览器交互，就是web项目了，所以打成war包

　　　　　　　　　　和前面一样，ssh_parent的pom.xml中增加一个module结点，而ssh_web的pom.xml中增加一个parent结点

　　　　　　　　　　这个也很简单，就是跟写普通的struts2是一样的，只不过是和spring的结合，有什么对象，都通过spring来给予，并且这里多做一个事情，就是将之前的applicationContext配置文件进行结合，看下图

　　　　　　　　　　　　　　　　　　　　

 application.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:p="http://www.springframework.org/schema/p"  
    xmlns:context="http://www.springframework.org/schema/context"   
    xmlns:tx="http://www.springframework.org/schema/tx"  
    xmlns:aop="http://www.springframework.org/schema/aop"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans    
    http://www.springframework.org/schema/beans/spring-beans.xsd    
    http://www.springframework.org/schema/aop    
    http://www.springframework.org/schema/aop/spring-aop.xsd    
    http://www.springframework.org/schema/tx    
    http://www.springframework.org/schema/tx/spring-tx.xsd    
    http://www.springframework.org/schema/context    
    http://www.springframework.org/schema/context/spring-context.xsd">

    <import resource="classpath:applicationContext-dao"/>
    <import resource="classpath:applicationContext-service"/>
    <import resource="classpath:applicationContext-web"/>
</beans>

 

　　　　　　　　　　web.xml中配置struts2的拦截器和spring的监听器

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
<!--spring配置文件的加载的监听 器-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>

    </context-param> 
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    
    
     <!--2.懒加载   OpenSessionInviewFilter   noSession or session is closed-->
    <filter>
        <filter-name>openSessionInViewFilter</filter-name>
        <filter-class>org.springframework.orm.hibernate5.support.OpenSessionInViewFilter</filter-class>
        <init-param>
            <param-name>singleSession</param-name>
            <param-value>true</param-value>

        </init-param>
        <init-param>
            <param-name>sessionFactoryBeanName</param-name>
            <param-value>sessionFactory</param-value>
        </init-param>
    </filter> 
    <filter-mapping>
        <filter-name>openSessionInViewFilter</filter-name>
        <url-pattern>/*</url-pattern>

    </filter-mapping> 
    
    
    
      <!--3.struts2核心控制器-->
     <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter> 
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping> 

</web-app>

web.xml

 

　　　　　　　　　　这里注意一个问题，struts跟spring整合的时候，Struts.xml中的class应该填写spring配置文件中的id。

 

　　　　　　2.5、总结与启动

　　　　　　　　　　　父工程和子模块都写完之后，就成这样了

　　　　　　　　　　　　　　

Boy_i
关注
专栏目录
Maven发布轻量二方包
Dkangel的博客
12-30 1815
在公共项目开发了common模块，其中包含了发钉钉消息、时间处理等多种公共方法，现在想要发布到maven仓库给其他应用使用。 其他应用使用过程中发现，引入common模块的依赖后还需要单独引用common内部的其他依赖。 client如果要使用发消息模块的能力，需要引入如下依赖： pom.xml: <!-- common内部发消息的依赖 --> <dependency> <groupId>com.dingtalk.open</groupId> <
Maven下载资源压缩包
07-09
Spring Boot 是一个快速构建Spring应用程序的框架，而Maven是一种项目管理工具，用于自动化构建Java项目。可以在Maven的pom.xml文件中添加Spring Boot的依赖来使用它的功能。
Maven2学习
05-24
NULL 博文链接：https://jeck218.iteye.com/blog/356949
maven(二) maven项目构建ssh工程(父工程与子模块的拆分与聚合)
weixin_34061482的博客
07-06 191
　　　　　　　　前一节我们明白了maven是个什么玩意，这一节就来讲讲他的一个重要的应用场景，也就是通过maven将一个ssh项目分割为不同的几个部分独立开发，很重要，加油 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　--WH   一、maven父工程与子模块的拆分与聚合原理 　　　　　　问题描述：将ssh工程拆分为多个模块开发 　　　　　　1.1、拆分原理 　　　　　　　　创建一...
maven项目构建ssh工程(父工程与子模块的拆分与聚合)
qq_36450099的博客
06-27 534
一，行家父工程与子模块的拆分与聚合原理　　　　　　问题描述：将SSH工程拆分为多个模块开发　　　　　　1.1，拆分原理　　　　　　　　创建一个maven project（pom），然后在创建三个子模块（maven moudule），其中三个子模块，分别为dao，service，web，也就是将三层的内容分别独立为一个项目，进一步将耦合性降低，其中如何将他们连接起来了，看下图。　　　　　　　　　　　...
Maven Web+SSH 项目搭建（Eclipse）
Vision's blog
07-08 2669
Maven Web+SSH 项目搭建（Eclipse） 配置环境：eclipse Neon Release (4.6.0) 、Tomcat-8.0.41、Apache-maven-3.5.0、Java1.8.0_121 以上环境搭建：http://blog.csdn.net/vision_tung/article/details/74553425#0-qzone-1-69432-d020d2d2a4
Maven2
qq_34819372的博客
04-03 198
【注】：转载至大佬智哥文档，仅做学习，略有删添【依赖传递】A ---》（B ---》C） A --- C A---》C a会间接的依赖c 依赖传递（1）排除依赖在依赖B的同时，排除对C的依赖传递&lt;exclusions&gt; &lt;exclusion&gt; 坐标信息 &lt;/exclusion&gt; &lt;/exclusions&gt;（2）中断依赖&...
Windoiws的maven3.8.8
04-03
### 二、安装步骤 1. **解压文件**：将下载的`apache-maven-3.8.8-bin.zip`文件解压到你选择的任意位置，例如`C:\Program Files`。 2. **设置环境变量**： - **Maven_HOME**：在系统环境变量中新建一个名为`Maven...
maven3.6的安装包
05-16
**二、解压与安装** 将下载的压缩包解压到你想要安装的目录，例如在Windows系统上，你可能会选择 `D:` 盘。解压后，你将看到一个结构如下： ``` D:\apache-maven-3.6.3 |- bin |- conf |- lib |- ... ``` **...
maven工程依赖
04-25
idea编译器中创建maven工程的时候，pom文件编写示例。
Maven2 快速入门
whusl的专栏
07-30 173
【什么是maven？】 参看《maven实战》，Maven主要服务于基于Java平台的项目构建、依赖管理和项目信息管理。 【为什么要Maven？】 Maven是一个异常强大的构建工具，能够帮我们自动化构建过程，从清理、编译、测试到生成报告，再到打包和部署。而且Maven是跨平台的，这意味着无论是在Windows上，还是在Linux或者Mac上，都可以使用同样的...
maven2
tourer2008的专栏
07-02 1735
概述Maven的目标对Maven的错误理解Maven的版本Maven的安装Windows 2000/xp下的安装基于Unxi－based的操作系统（Linux，Solaris and Mac OS X）查看依赖库的位置 http://mvnrepository.com/Maven主要功能构建项目
Maven_2
StrawBerry_Uncle的博客
06-23 159
&lt;dependency&gt; &lt;groupId&gt;org.apache.httpcomponents&lt;/groupId&gt; &lt;artifactId&gt;httpclient&lt;/artifactId&gt; &lt;version&gt;4.5.3&lt;/version&gt; &lt;/dependency&am
Maven2使用手册（转载）
xiaoliu216的专栏
10-06 210
1.1. Maven2 体验 声明:本节内容来源于blogjava网站jbob的blog 本节的版权归原作者所有，不适用本手册的版权申明。 maven是一个java项目管理工具，深化了ant，但又有自己一整套的项目集成策略。目前的版本是2.0.2。 1. maven网站 下载maven2，解压缩 2. 配置环境变量:maven_h...
Maven 2 详细教程
wei_ya_wen的专栏
01-05 1642
开始之前 现代软件开发基于健壮的企业级开源技术，它需要一类新的构建工具和项目协作工具。Apache Maven 2 的核心引擎旨在简化往往十分复杂的大型协作性软件项目的构建和管理。在大型项目团队环境中工作是种挑战，而 Maven 2 以友好为设计目的，即便对那些不熟悉这种挑战的开发人员而言，Maven 2 也足够友好。本教程首先围绕单个的新手开发展开，然后逐渐介绍 Maven 2 中的一些协作性
Maven_2(jar包冲突、锁定和统一管理jar、分模块、私服、安装第三方jar)
weixin_44051048的博客
12-15 934
文章目录Maven高级应用1、Maven基础知识回顾：2、案例：传统web工程做数据查询2.1 jar包冲突问题：1、什么是jar包冲突？？2、怎么解决jar包冲突问题？？2.2 锁定jar包版本：2.3 统一管理jar包版本3、分模块构建工程3.1 为什么要分模块构建工程Maven工程的拆分和聚合的思想3.2 理解继承与聚合（工程的模块化）3.3 分模块工程的三种启动方式1、案例：2、三种启动方式：4、私服4.1 简介：4.2 下载安装启动私服4.3 仓库的类型：4.5 （重点）将项目发布到私服4.6
Maven.2
最新发布
TTG223的博客
07-25 400
那么在主带码，测试代码，打包中，主带码基本是静态的，而test测试代码则是经常运行进行测试，测试运行完，便是打包，将jar包存放至本地仓库。很好理解，当spring-core依赖出现冲突时，在不影响项目运行的情况下，可以将该冲突排除掉，即避让冲突。可以在main包下的java运行生效，也可以在test包下的测试java中生效，也不影响打包中的jar。依赖冲突是指项目依赖的某一个jar包，有多个不同的版本，因而造成类包版本冲突。：被依赖的资源，如果还依赖其他资源，那么当前项目间接依赖其他资源。
Apache Maven入门与实践
Maven 的安装包括验证Java环境、下载Maven二进制包、安装到系统路径，以及配置用户特定的设置，如本地仓库位置。验证安装可通过运行 `mvn -version` 命令查看。 7. Maven 插件和目标 Maven 插件包含一系列目标...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值