精华内容
下载资源
问答
  • Maven拆分代码.zip

    2020-05-29 00:05:19
    <property name="url" value="jdbc:mysql:///maven"/> <!--配置生产SqlSession对象的工厂--> <!--扫描pojo包,给包下所有pojo对象起别名--> <!--扫描接口包路径,生成包下所有接口的代理对象,...
  • 使用maven拆分项目

    2018-02-24 18:15:00
    在开发环境中,有时需要专人负责专门的模块,其他模块不需接触,这就需要将项目拆分,如下   fund_demo项目具有三个模块,现将主业务core模块单独提出另建一个项目fund_core,拆分时需要注意相关类的路径在映射...

    在开发环境中,有时需要专人负责专门的模块,其他模块不需接触,这就需要将项目拆分,如下

        

    fund_demo项目具有三个模块,现将主业务core模块单独提出另建一个项目fund_core,拆分时需要注意相关类的路径在映射文件中要保持正确

        

     这就需要当运行fund_demo时也要调用fund_core项目,开发情况下可将fund_core项目作为依赖加入fund_demo,但打包时却不方便,这就需要用到maven来管理

    1. 同一工作空间下新建父项目fund_parent,并编辑pom.xml

        <groupId>cn.zang</groupId>
        <artifactId>fund_parent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <!-- 打包方式为pom -->
        <packaging>pom</packaging>
    
        <!-- 引入子项目 -->
        <modules>
            <module>../fund_core</module>
            <module>../fund_demo</module>
        </modules>

    2. 编辑子项目的pom.xml

    fund_demo:声明父元素,引入fund_core的依赖

    <!--声明父元素-->
        <parent>
            <groupId>cn.zang</groupId>
            <artifactId>fund_parent</artifactId>
            <version>0.0.1-SNAPSHOT</version>
            <relativePath>../fund_parent</relativePath>
        </parent>
        
        <groupId>cn.zang</groupId>
        <artifactId>fund_demo</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <packaging>jar</packaging>
    
        <name>fund</name>
        <url>http://maven.apache.org</url>
    
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        </properties>
    
        <dependencies>
    <!--引入fund_core的依赖-->
            <dependency>
                <groupId>cn.zang</groupId>
                <artifactId>fund_core</artifactId>
                <version>0.0.1-SNAPSHOT</version>
            </dependency>    
      ······
       </dependencies>

    fund_core:声明父元素

    <!--声明父元素-->
        <parent>
            <groupId>cn.zang</groupId>
            <artifactId>fund_parent</artifactId>
            <version>0.0.1-SNAPSHOT</version>
            <relativePath>../fund_parent</relativePath>
        </parent>
        
        <groupId>cn.zang</groupId>
        <artifactId>fund_core</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <packaging>jar</packaging>

    3. fund_parent项目编译发布

    call mvn clean compile
    call mvn eclipse:clean
    call mvn eclipse:eclipse -Dwtpversion=2.0 -DdownloadSources=true -DdownloadJavadocs=true
    pause

    4. 在项目中引入父项目时即可自动将两个子项目引入

     

    展开全文
  • maven工程拆分与聚合的思想 工程和 模块的区别 工程不等于完整的项目,模块也不等于完整的项目,一个完整的项目看的是代码,代码完整就可以说是一个完整的项目 和此项目是工程和模块没有关系 区别: 工程天生只能使用...

    拆分和聚合的代码demo可点击链接下载:demo代码

    一、 maven工程拆分与聚合的思想

    在这里插入图片描述

    工程和 模块的区别

    工程不等于完整的项目,模块也不等于完整的项目,一个完整的项目看的是代码,代码完整就可以说是一个完整的项目

    和此项目是工程和模块没有关系

    区别:

    工程天生只能使用自己内部资源,工程天生是独立的.后天可以和其他工程或模块建立关联关系

    模块天生不是独立的,模块天生是属于父工程的,模块一旦创建,所有父工程资源都可以使用.

    联系:

    父子工程之间,子模块天生继承父工程,可以使用父工程所有资源.
    子模块之间天生是没有任何关系的.

    父子工程之间不用建立关系,继承关系是先天的,不需要手动建立。

    平级之间的引用叫依赖,依赖是后天建立的,不是天生的。

    在这里插入图片描述

    直接依赖和传递依赖

    直接依赖:dao直接依赖于parent,作用域是compile
    传递依赖:dao和junit是传递依赖,作用域是test

    在这里插入图片描述

    二、使用maven做构建ssm框架(传统聚合的项目)

    maven传统的web工程做一个数据查询操作

    (1)SSM框架下的dao层代码编写

    a. 先创建数据库对应的实体类,属性名和数据库的字段名要相对应

    b. 创建操作数据库的接口,并且定义抽象方法publicItemsfindById(Integerid);

    因为使用ssm框架,接口对应的是mybatis的持久层框架,则接口不用写实现类,让mybatis直接生成接口的代理对象即可

    c.在resources文件夹下创建和src目录结构相同的目录,并且创建接口的配置文件(XML),用于操作数据库——操作数据库定义一个mapper进行操作,如下:

    在这里插入图片描述
    d. 创建spring的配置文件,希望spring整合mybatis框架,则需要配置连接池连接数据库,配置生成sqlsession工厂,扫描包中接口的路径

    在这里插入图片描述
    e. 编写测试类,测试是否配置成功
    在这里插入图片描述

    (2)SSM框架下的service层代码编写

    公司实际开发中:自己写的类尽量使用注解,框架中的类使用配置文件、
    
    1. 创建service层的接口 (方法名此时和dao层的操作的方法名一致)
      在这里插入图片描述

    2. 为service层的接口添加实现类,并且把dao的操作对象进行注入,因为itemsdao是自己写的类,所以加上注解的方式交由spring的aop进行注入(原本没有值的,加上一个值)
      在这里插入图片描述

    3. 编写service层的配置文件,实现业务层处理业务逻辑和处理事务的功能配置,
      ①配置组件的扫描,(aop面向切面编程,切面就是切入点和通知的组合)
      ②配置事务管理器(想要控制事务,就要用到connection,用到connection就要用到连接池),
      ③配置事务的通知,
      ④配置切面(并且需要把切入点和通知类进行整合,变成切面)
      在这里插入图片描述

    4. 编写测试

    在这里插入图片描述

    (3)SSM框架下的web层代码编写

    1. 创建web层的控制类,需要在类上加上 @Controller @RequestMapping("/items") 即把对象交给容器管理并且加上全局路径,
      在这里插入图片描述

    2. 由于applicationContext.xml文件是用来配置spring框架的,而web层采用的是springmvc框架,所以建立一个springmvc.xml文件用于配置web层,并把springmvc.xml的配置文件导入我们需要的context、aop、mvc、tx等约束
      ① 配置组件扫描
      ②开启springmvc的注解支持(处理器映射器、处理器适配器)
      ③配置视图解析器
      ④释放静态资源
      在这里插入图片描述

    3. 在/WEN-INF/pages/目录下创建要跳转的视图文件 itemDetail.jsp
      在这里插入图片描述

    4. 为了把所有配置文件的资源一启动就交给servlet容器中,则需要配置web.xml
      ① 配置编码过滤器
      ② 配置spring文件扫描——配置spring核心监听器
      ③ springmvc的核心servlet

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    三、把传统聚合的项目进行拆分的具体步骤

    之前的项目把dao、service、web层都放在了一个项目中,现在进行拆分成模块并借助依赖的方式进行导入。
    在这里插入图片描述

    理解继承和聚合

    通常继承和聚合同时使用。

     何为继承?

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

     何为聚合?

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

    • 拆分之前的目录结构:
      在这里插入图片描述

    • 拆分之后的项目目录结构:
      在这里插入图片描述
      每个模块都需要 spring 或者 junit 的 jar,况且最终 package 打完包最后生成的项目中的jar 就是各个模块依赖的整合,所以我们可以把项目中所需的依赖都可以放到父工程中,模块中只留模块和模块之间的依赖。

    (1)dao层模块:

    在这里插入图片描述
    在这里插入图片描述
    dao中对spring的配置也只配置dao层的,不加入service的配置

    (2)service层模块:

    在这里插入图片描述
    在这里插入图片描述

    (3) Web 层模块:

    在这里插入图片描述
    在这里插入图片描述
    web层包含web层的页面资源等,并且导入对dao和service层的配置文件的扫描

    其中,web层的web.xml文件是对web层的配置文件,里面可以包含配置spring核心监听器和springmvc的核心servlet等

    展开全文
  • maven基础回顾 maven是一个项目管理工具 依赖管理: 对项目中jar包的管理,传统工程直接把jar包放置在项目中,maven工程中把jar包放在仓库中。 仓库的分类: 本地仓库、远程仓库(私服)、中央仓库 仓库间的关系: ...

    maven基础回顾


    maven是一个项目管理工具
    依赖管理:
    对项目中jar包的管理,传统工程直接把jar包放置在项目中,maven工程中把jar包放在仓库中。

    仓库的分类:
    本地仓库、远程仓库(私服)、中央仓库

    仓库间的关系:
    启动一个maven工程时,maven工程会根据pom.xml文件中jar包坐标去本地仓库寻找,如果本地仓库没有,默认会自动去中央仓库下载jar包到本地仓库。
    在公司中会先从私服下载jar包,如果私服没有可以从中央仓库下载或从本地上传。


    一键构建:
    maven自身集成了tomcat插件,可以对项目进行编译,测试,打包,安装,发布等操作。

    常用命令:
    clean 清理之前的构建信息
    compile 对src/main/java下的代码编译
    test 编译测试代码
    package 打包本地项目到target目录下
    install 把包安装到本地仓库
    deploy 打包本地项目到私服

    生命周期:
    清理生命周期 clean
    默认生命周期 compile->deploy
    站点生命周期


    构建SSM工程

    创建数据库表

    CREATE TABLE `items` (
      `id` INT(10) NOT NULL AUTO_INCREMENT,
      `name` VARCHAR(20) DEFAULT NULL,
      `price` FLOAT(10,0) DEFAULT NULL,
      `pic` VARCHAR(40) DEFAULT NULL,
      `createtime` DATETIME DEFAULT NULL,
      `detail` VARCHAR(200) DEFAULT NULL,
      PRIMARY KEY  (`id`)
    ) ENGINE=INNODB DEFAULT CHARSET=utf8;
    
    INSERT INTO `items` VALUES ('1', '湖人球票', '1000', NULL, '2019-02-07 09:29:30', '湖人vs快船');
    INSERT INTO `items` VALUES ('2', '科比球衣','599', NULL, '2018-03-28 10:05:52', 'rip');
    INSERT INTO `items` VALUES ('3', 'N95口罩', '199', NULL, '2018-03-07 10:08:04', '买不到');
    

    搭建环境

    创建一个新的maven工程
    在这里插入图片描述
    在最后一步添加以下属性提高项目构建速度
    在这里插入图片描述


    当只导入以下依赖时,发现还出现了其他依赖的jar包,这种现象叫依赖传递
    在这里插入图片描述
    在这里插入图片描述


    解决jar包冲突的方式
    方式一 第一声明优先原则

    哪个jar包靠上配置,它所依赖的包优先进入项目中
    例:加入以下配置,发现有的包版本变为5.0.2
    在这里插入图片描述
    在这里插入图片描述

    方式二 路径近优先原则
    直接依赖路径比传递依赖路径近,最终进入项目的jar包是路径近的直接依赖包
    直接依赖:项目中直接导入的jar包
    传递依赖:项目中没有直接导入的jar包,通过直接依赖包传递到项目中
    例:增加以下配置,发现版本变回5.2.1
    在这里插入图片描述
    在这里插入图片描述


    方式三 排除依赖(推荐使用)

    当我们要排除某个jar包下的依赖包时,在配置exclusion标签时可以不写版本号,因为此时依赖包所使用的版本默认和本jar包一样。
    例:排除core包
    在这里插入图片描述
    在这里插入图片描述


    锁定版本

    面对众多的依赖,有一种方法不用考虑依赖路径、声明优化等因素可以采用直接锁定版
    本的方法确定依赖构件的版本,版本锁定后则不考虑依赖的声明顺序或依赖的路径,以锁定
    的版本的为准添加到工程中,此方法在企业开发中常用。
    把版本号提取出来,使用<properties>标签设置成变量。

    完整的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.sjh</groupId>
      <artifactId>maven</artifactId>
      <version>1.0-SNAPSHOT</version>
      <packaging>war</packaging>
    
    
      <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <spring.version>5.2.1.RELEASE</spring.version>
        <slf4j.version>1.6.6</slf4j.version>
        <log4j.version>1.2.17</log4j.version>
        <shiro.version>1.2.3</shiro.version>
        <mysql.version>5.1.44</mysql.version>
        <mybatis.version>3.4.5</mybatis.version>
        <spring.security.version>5.2.1.RELEASE</spring.security.version>
      </properties>
    
      <dependencies>
        <!-- spring -->
        <dependency>
          <groupId>org.aspectj</groupId>
          <artifactId>aspectjweaver</artifactId>
          <version>1.9.4</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-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>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-test</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-tx</artifactId>
          <version>${spring.version}</version>
        </dependency>
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.12</version>
          <scope>test</scope>
        </dependency>
        <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
          <version>${mysql.version}</version>
        </dependency>
        <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>javax.servlet-api</artifactId>
          <version>3.1.0</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>jstl</groupId>
          <artifactId>jstl</artifactId>
          <version>1.2</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 -->
        <dependency>
          <groupId>org.mybatis</groupId>
          <artifactId>mybatis</artifactId>
          <version>${mybatis.version}</version>
        </dependency>
        <dependency>
          <groupId>org.mybatis</groupId>
          <artifactId>mybatis-spring</artifactId>
          <version>1.3.0</version>
        </dependency>
        <dependency>
          <groupId>com.alibaba</groupId>
          <artifactId>druid</artifactId>
          <version>1.0.9</version>
        </dependency>
      </dependencies>
      
     
    </project>
    
    

    dao层代码编写

    配置以下文件夹
    在这里插入图片描述
    创建对应数据库表的实体类Item

    package com.pojo;
    
    import java.util.Date;
    
    public class Item {
        private Integer id;
        private String name;
        private Float price;
        private String pic;
        private Date createtime;
        private String detail;
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Float getPrice() {
            return price;
        }
    
        public void setPrice(Float price) {
            this.price = price;
        }
    
        public String getPic() {
            return pic;
        }
    
        public void setPic(String pic) {
            this.pic = pic;
        }
    
        public Date getCreatetime() {
            return createtime;
        }
    
        public void setCreatetime(Date createtime) {
            this.createtime = createtime;
        }
    
        public String getDetail() {
            return detail;
        }
    
        public void setDetail(String detail) {
            this.detail = detail;
        }
    
        @Override
        public String toString() {
            return "Item{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", price=" + price +
                    ", pic='" + pic + '\'' +
                    ", createtime=" + createtime +
                    ", detail='" + detail + '\'' +
                    '}';
        }
    }
    

    在resouces目录下新建springConfig.xml配置文件,对dao层进行相关配置

    <?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:aop="http://www.springframework.org/schema/aop"
           xmlns:tx="http://www.springframework.org/schema/tx"
           xmlns:mvc="http://www.springframework.org/schema/mvc"
           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.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/mvc
    			    http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    
        <!--配置dao层-->
        <!-- 1 配置数据源 -->
        <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
            <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql:///test?serverTimezone=UTC"/>
            <property name="username" value="root"/>
            <property name="password" value=""/>
        </bean>
    
        <!-- 2 配置sqlSession工厂生产sqlsession -->
        <bean id="sessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="dataSource" ref="dataSource"/>
        </bean>
    
        <!-- 扫描接口包路径,生成包下所有接口的代理对象,放入spring容器-->
        <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            <property name="basePackage" value="com.dao"/>
        </bean>
        <!--配置dao层结束-->
    
    
    </beans>
    

    创建操作Item的dao接口

    package com.dao;
    
    import com.pojo.Item;
    import org.apache.ibatis.annotations.Select;
    
    public interface ItemDao {
    
        @Select("select * from items where id=#{id}")
        Item findById(int id);
    }
    

    创建测试类,进行测试

    public class ItemTest {
    
        @Test
        public void findById(){
            ApplicationContext ac=new ClassPathXmlApplicationContext("springConfig.xml");
            ItemDao itemDao = ac.getBean(ItemDao.class);
            Item item = itemDao.findById(1);
            System.out.println(item);
        }
    }
    

    结果:
    在这里插入图片描述


    service层代码编写

    service层的接口和实现类

    public interface ItemService {
    
        Item findById(int id);
    }
    
    @Service
    public class ItemServiceImpl implements ItemService {
    
        @Autowired
        private ItemDao itemDao;
    
        @Override
        public Item findById(int id) {
            return itemDao.findById(id);
        }
    }
    
    

    在springConfig.xml中增加对service层的配置

    <!--配置service层-->
        <!-- 组件扫描 -->
        <context:component-scan base-package="com"/>
        <!--配置事务管理器 -->
        <bean id="tranManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <property name="dataSource" ref="dataSource"/>
        </bean>
        <tx:advice id="interceptor" transaction-manager="tranManager">
            <tx:attributes>
                <tx:method name="find*" read-only="true"/>
                <!-- 除了查询外的增删改需要事务-->
                <tx:method name="update*" propagation="REQUIRED"/>
                <tx:method name="delete*" propagation="REQUIRED"/>
                <tx:method name="save*" propagation="REQUIRED"/>
            </tx:attributes>
        </tx:advice>
        <!-- 配置切面 -->
        <aop:config>
            <aop:pointcut id="pointcut" expression="execution(* com.service.*.*(..))"/>
            <aop:advisor advice-ref="interceptor" pointcut-ref="pointcut"/>
        </aop:config>
        <!--配置service层结束-->
    

    在测试类中进行测试

    @Test
        public void findById(){
            ApplicationContext ac=new ClassPathXmlApplicationContext("springConfig.xml");
            ItemService service = ac.getBean(ItemService.class);
            Item item = service.findById(1);
            System.out.println(item);
        }
    

    在这里插入图片描述


    web层代码编写

    新建一个控制器类

    @Controller
    @RequestMapping("/items")
    public class ItemController {
    
        @Autowired
        private ItemService itemService;
    
        @RequestMapping("/find")
        public String findById(Model model,int id){
            Item item = itemService.findById(id);
            model.addAttribute("item",item);
            return "itemDetail";
        }
    
    }
    

    前端index.jsp

    <%@ page language="java" contentType="text/html; charset=UTF-8"
             pageEncoding="UTF-8"%>
    <html>
    <body>
    <h2>Hello World!</h2>
    
    
    <form action="items/find" method="post">
        输入要查询商品的id号:<input type="text" name="id"><br>
        <input type="submit">
    </form>
    
    </body>
    </html>
    

    在WEB-INF/pages下新建itemDetail.jsp

    <%@ page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8"%>
    <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
    <%@ taglib uri="http://java.sun.com/jsp/jstl/fmt"  prefix="fmt"%>    
     
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>Insert title here</title>
    </head>
    <body> 
    	<form>
    		<table width="100%" border=1>
    			<tr>
    				<td>商品名称</td>
    				<td> ${item.name } </td>
    			</tr>
    			<tr>
    				<td>商品价格</td>
    				<td> ${item.price } </td>
    			</tr>
    			<tr>
    				<td>生成日期</td>
    				<td> <fmt:formatDate value="${item.createtime}" pattern="yyyy-MM-dd HH:mm:ss"/> </td>
    			</tr>
    			<tr>
    				<td>商品简介</td>
    				<td>${item.detail} </td>
    			</tr>
    		</table>
    	</form>
    </body>
    </html>
    

    配置mvc

    <?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:mvc="http://www.springframework.org/schema/mvc"
           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.xsd
    			    http://www.springframework.org/schema/mvc
    			    http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    
        <!-- 配置组件扫描 -->
        <context:component-scan base-package="com.controller"/>
    
        <!-- 配置处理器映射器和处理器适配器 -->
        <mvc:annotation-driven/>
    
        <!-- 配置视图解析器 -->
        <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/WEB-INF/pages/"/>
            <property name="suffix" value=".jsp"/>
        </bean>
    
        <!-- 释放静态资源 -->
        <mvc:default-servlet-handler/>
    
    
    </beans>
    

    修改web.xml配置

     <!--配置编码过滤器 -->
      <filter>
        <filter-name>filter</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>filter</filter-name>
        <url-pattern>/*</url-pattern>
      </filter-mapping>
    
      <!-- 配置前端控制器 -->
      <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 读取spring*.xml -->
        <init-param>
          <param-name>contextConfigLocation</param-name>
          <param-value>classpath:spring*.xml</param-value>
        </init-param>
        <!-- 启动后加载 -->
        <load-on-startup>1</load-on-startup>
      </servlet>
    
      <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <!-- 匹配除jsp之外的所有资源-->
        <url-pattern>/</url-pattern>
      </servlet-mapping>
    

    配置tomcat服务器,启动测试
    在这里插入图片描述
    在这里插入图片描述


    构建maven父子工程

    传统maven工程存在的问题

    继承是为了消除重复,如果将 dao、service、web 分开创建独立的工程则每个工程的 pom.xml文件中的内容存在重复,比如:设置编译版本、锁定 spring 的版本的等,可以将这些重复的配置提取出来在父工程的 pom.xml 中定义。
    项目开发通常是分组分模块开发,每个模块开发完成要运行整个工程需要将每个模块聚合在
    一起
    运行,比如:dao、service、web 三个工程最终会打一个独立的 war 运行。


    构建父子工程模块

    新建一个maven工程,不需要使用骨架
    在这里插入图片描述
    可以将src目录删掉
    在这里插入图片描述
    右键maven_parent文件夹新建一个module,不需要使用骨架
    在这里插入图片描述
    可以看到新建的子模块的pom.xml文件具有parent标签
    在这里插入图片描述
    而父工程的pom.xml文件也多了module标签
    在这里插入图片描述
    依次再建立service和web的子模块(web模块需要使用webapp的骨架),可以删除web模块pom.xml文件中的多余部分,只保留以下模块
    在这里插入图片描述
    完整的父子工程结构
    在这里插入图片描述


    工程和模块的区别

    • 工程不等于完整的项目,模块也不等于完整的项目,一个完整的项目看的是代码是否完整
    • 工程初始只能使用自己内部的资源,是独立的,后面可以手动和其他工程和模块建立关系
    • 模块初始不是独立的,属于父工程,模块一旦创立,所有父工程的资源都能使用
    • 父子工程中,子模块初始集成父工程,可以使用父工程所有资源,但子模块之间初始不能互相使用资源,需要配置联系
    • 父子工程中不用建立关系,继承关系是先天的,不需要手动建立
    • 平级之间的引用叫依赖,依赖不是先天的,需要手动建立

    在service层中引用dao的配置
    在这里插入图片描述

    在web中引用service的配置
    在这里插入图片描述


    把之前ssm项目的pom文件中依赖导入当前父工程的pom文件

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <spring.version>5.2.1.RELEASE</spring.version>
        <slf4j.version>1.6.6</slf4j.version>
        <log4j.version>1.2.17</log4j.version>
        <shiro.version>1.2.3</shiro.version>
        <mysql.version>5.1.44</mysql.version>
        <mybatis.version>3.4.5</mybatis.version>
        <spring.security.version>5.2.1.RELEASE</spring.security.version>
      </properties>
    
      <dependencies>
        <!-- spring -->
        <dependency>
          <groupId>org.aspectj</groupId>
          <artifactId>aspectjweaver</artifactId>
          <version>1.9.4</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-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>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-test</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-tx</artifactId>
          <version>${spring.version}</version>
        </dependency>
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.12</version>
          <scope>test</scope>
        </dependency>
        <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
          <version>${mysql.version}</version>
        </dependency>
        <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>javax.servlet-api</artifactId>
          <version>3.1.0</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>jstl</groupId>
          <artifactId>jstl</artifactId>
          <version>1.2</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 -->
        <dependency>
          <groupId>org.mybatis</groupId>
          <artifactId>mybatis</artifactId>
          <version>${mybatis.version}</version>
        </dependency>
        <dependency>
          <groupId>org.mybatis</groupId>
          <artifactId>mybatis-spring</artifactId>
          <version>1.3.0</version>
        </dependency>
        <dependency>
          <groupId>com.alibaba</groupId>
          <artifactId>druid</artifactId>
          <version>1.0.9</version>
        </dependency>
      </dependencies>
    

    引入dao层代码

    将之前的dao包和pojo包以及关于dao的spring配置引入
    在这里插入图片描述
    spring-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"
    
           xsi:schemaLocation="http://www.springframework.org/schema/beans
    			    http://www.springframework.org/schema/beans/spring-beans.xsd">
    
        <!--配置dao层-->
        <!-- 1 配置数据源 -->
        <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
            <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql:///test?serverTimezone=UTC"/>
            <property name="username" value="root"/>
            <property name="password" value=""/>
        </bean>
    
        <!-- 2 配置sqlSession工厂生产sqlsession -->
        <bean id="sessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="dataSource" ref="dataSource"/>
        </bean>
    
        <!-- 扫描接口包路径,生成包下所有接口的代理对象,放入spring容器-->
        <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            <property name="basePackage" value="com.dao"/>
        </bean>
        <!--配置dao层结束-->
    
    </beans>
    

    引入service层代码

    将之前的service包以及关于service的spring配置引入
    在这里插入图片描述
    spring-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:context="http://www.springframework.org/schema/context"
           xmlns:aop="http://www.springframework.org/schema/aop"
           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.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">
    
    
        <!--配置service层-->
        <!-- 组件扫描 -->
        <context:component-scan base-package="com.service"/>
        <!--配置事务管理器 -->
        <bean id="tranManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <property name="dataSource" ref="dataSource"/>(这里报红不用管)
        </bean>
        <tx:advice id="interceptor" transaction-manager="tranManager">
            <tx:attributes>
                <tx:method name="find*" read-only="true"/>
                <!-- 除了查询外的增删改需要事务-->
                <tx:method name="update*" propagation="REQUIRED"/>
                <tx:method name="delete*" propagation="REQUIRED"/>
                <tx:method name="save*" propagation="REQUIRED"/>
            </tx:attributes>
        </tx:advice>
        <!-- 配置切面 -->
        <aop:config>
            <aop:pointcut id="pointcut" expression="execution(* com.service.*.*(..))"/>
            <aop:advisor advice-ref="interceptor" pointcut-ref="pointcut"/>
        </aop:config>
        <!--配置service层结束-->
    </beans>
    

    引入web层代码

    将之前的controller包以及关于mvc的spring配置、前端页面、web.xml引入
    在这里插入图片描述

    在springmvc.xml中加入

    	<!-- 引入service和dao的配置 -->
        <import resource="classpath:spring-dao.xml"/>
        <import resource="classpath:spring-service.xml"/>
    

    测试

    对maven_web子工程配置tomcat服务器并启动
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述


    展开全文
  • === maven拆分各层配置后,【pom.xml、Spring配置都按层拆分(dao/service/action)】,导致报错解决。 Spring配置拆分: =====错误信息:service创建失败。 ===老师:找不到service层Spring配置。 ...

    === maven拆分各层配置后,【pom.xml、Spring配置都按层拆分(dao/service/action)】,导致报错解决。

    Spring配置拆分:===【各层只配置本层相关配置。】

    ①dao:applicationContext-dao.xml  

    <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:aop="http://www.springframework.org/schema/aop" 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.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">
    
    	
    	<!-- 数据库连接池 -->
    	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    		<property name="driverClass" value="com.mysql.jdbc.Driver" />
    		<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/maven" />
    		<property name="user" value="root" />
    		<property name="password" value="root" />
    	</bean>
    
    	<!-- 配置sessionFactory -->
    	<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
    		<!-- 依赖dataSource -->
    		<property name="dataSource" ref="dataSource"/>
    		<!-- 创建工厂需要加载hibernate映射文件 -->
    		<property name="configLocations" value="classpath:hibernate.cfg.xml"></property>
    	</bean>
    	
    	<bean name="customerDao" class="cn.heima.dao.impl.CustomerDaoImpl">
    		<property name="sessionFactory" ref="sessionFactory"></property>
    	</bean>
    	
    </beans>

    ②service:applicationContext-service.xml

    <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:aop="http://www.springframework.org/schema/aop" 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.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">
    
    	<!-- 事务属于service层 -->
    	<bean  id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
    	<property name="sessionFactory" ref="sessionFactory"></property>
    	</bean>
    	
    	<tx:advice id="advice" transaction-manager="transactionManager">
    	<tx:attributes>
    	 <tx:method name="find*" read-only="true" />
    	</tx:attributes>
    	</tx:advice>
    	
    	<aop:config>
    	 <aop:pointcut  id="serviceMethod"  expression="execution(* cn.heima.service.impl.*.*(..))"/>
    	 <aop:advisor advice-ref="advice" pointcut-ref="serviceMethod"/>
    	</aop:config>
    	
    	<bean name="customerService" class="cn.heima.service.impl.CustomerServiceImpl">
    		<property name="customerDao" ref="customerDao"></property>
    	</bean>
    	
    	
    </beans>

    ③action:applicationContext-action.xml

    <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:aop="http://www.springframework.org/schema/aop" 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.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">
    
    	
    	
    	<bean name="customerAction" class="cn.heima.action.CustomerAction" scope="prototype">
    		<property name="customerService" ref="customerService"></property>
    	</bean>
    	
    	
    </beans>

    修改web.xml:读取spring配置文件

    <listener>
      	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
      </listener>
      <context-param>
      	<!-- ContextLoaderListener 父类里-->
      	<param-name>contextConfigLocation</param-name>
    <!--   	 <param-value>classpath:applicationContext.xml</param-value> -->
    
       	 <param-value>classpath:applicationContext-*.xml</param-value> 	 
      </context-param>



    =====错误信息:service创建失败。

    ===老师:找不到service层Spring配置。

    HTTP Status 500 -
    
    type Exception report
    
    message
    
    description The server encountered an internal error () that prevented it from fulfilling this request.
    
    exception
    
    Unable to instantiate Action, customerAction,  defined for 'customerAction_findByCustId' in namespace '/'Error creating bean with name 'customerAction' defined in file [F:\EclipseWorkSpace\ssh_parent\ssh_web\target\classes\applicationContext-action.xml]: Cannot resolve reference to bean 'customerService' while setting bean property 'customerService'; nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No bean named 'customerService' is defined - action - file:/F:/EclipseWorkSpace/ssh_parent/ssh_web/target/classes/struts.xml:9:72
    	com.opensymphony.xwork2.DefaultActionInvocation.createAction(DefaultActionInvocation.java:314)
    	com.opensymphony.xwork2.DefaultActionInvocation.init(DefaultActionInvocation.java:395)
    	com.opensymphony.xwork2.DefaultActionProxy.prepare(DefaultActionProxy.java:194)
    	org.apache.struts2.impl.StrutsActionProxy.prepare(StrutsActionProxy.java:63)
    	org.apache.struts2.impl.StrutsActionProxyFactory.createActionProxy(StrutsActionProxyFactory.java:37)
    	com.opensymphony.xwork2.DefaultActionProxyFactory.createActionProxy(DefaultActionProxyFactory.java:58)
    	org.apache.struts2.dispatcher.Dispatcher.serviceAction(Dispatcher.java:554)
    	org.apache.struts2.dispatcher.ng.ExecuteOperations.executeAction(ExecuteOperations.java:81)
    	org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter.doFilter(StrutsPrepareAndExecuteFilter.java:99)
    root cause
    
    org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'customerAction' defined in file [F:\EclipseWorkSpace\ssh_parent\ssh_web\target\classes\applicationContext-action.xml]: Cannot resolve reference to bean 'customerService' while setting bean property 'customerService'; nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No bean named 'customerService' is defined
    	org.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveReference(BeanDefinitionValueResolver.java:359)
    	org.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveValueIfNecessary(BeanDefinitionValueResolver.java:108)
    	org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.applyPropertyValues(AbstractAutowireCapableBeanFactory.java:1481)
    	org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean(AbstractAutowireCapableBeanFactory.java:1226)
    	org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:543)
    	org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:482)
    	org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:325)
    	org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:197)
    	org.springframework.context.support.AbstractApplicationContext.getBean(AbstractApplicationContext.java:1054)
    	com.opensymphony.xwork2.spring.SpringObjectFactory.buildBean(SpringObjectFactory.java:161)
    	com.opensymphony.xwork2.ObjectFactory.buildBean(ObjectFactory.java:178)
    	com.opensymphony.xwork2.factory.DefaultActionFactory.buildAction(DefaultActionFactory.java:22)
    	com.opensymphony.xwork2.ObjectFactory.buildAction(ObjectFactory.java:148)
    	com.opensymphony.xwork2.DefaultActionInvocation.createAction(DefaultActionInvocation.java:295)
    	com.opensymphony.xwork2.DefaultActionInvocation.init(DefaultActionInvocation.java:395)
    	com.opensymphony.xwork2.DefaultActionProxy.prepare(DefaultActionProxy.java:194)
    	org.apache.struts2.impl.StrutsActionProxy.prepare(StrutsActionProxy.java:63)
    	org.apache.struts2.impl.StrutsActionProxyFactory.createActionProxy(StrutsActionProxyFactory.java:37)
    	com.opensymphony.xwork2.DefaultActionProxyFactory.createActionProxy(DefaultActionProxyFactory.java:58)
    	org.apache.struts2.dispatcher.Dispatcher.serviceAction(Dispatcher.java:554)
    	org.apache.struts2.dispatcher.ng.ExecuteOperations.executeAction(ExecuteOperations.java:81)
    	org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter.doFilter(StrutsPrepareAndExecuteFilter.java:99)
    root cause
    
    org.springframework.beans.factory.NoSuchBeanDefinitionException: No bean named 'customerService' is defined
    	org.springframework.beans.factory.support.DefaultListableBeanFactory.getBeanDefinition(DefaultListableBeanFactory.java:698)
    	org.springframework.beans.factory.support.AbstractBeanFactory.getMergedLocalBeanDefinition(AbstractBeanFactory.java:1175)
    	org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:284)
    	org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:197)
    	org.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveReference(BeanDefinitionValueResolver.java:351)
    	org.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveValueIfNecessary(BeanDefinitionValueResolver.java:108)
    	org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.applyPropertyValues(AbstractAutowireCapableBeanFactory.java:1481)
    	org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean(AbstractAutowireCapableBeanFactory.java:1226)
    	org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:543)
    	org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:482)
    	org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:325)
    	org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:197)
    	org.springframework.context.support.AbstractApplicationContext.getBean(AbstractApplicationContext.java:1054)
    	com.opensymphony.xwork2.spring.SpringObjectFactory.buildBean(SpringObjectFactory.java:161)
    	com.opensymphony.xwork2.ObjectFactory.buildBean(ObjectFactory.java:178)
    	com.opensymphony.xwork2.factory.DefaultActionFactory.buildAction(DefaultActionFactory.java:22)
    	com.opensymphony.xwork2.ObjectFactory.buildAction(ObjectFactory.java:148)
    	com.opensymphony.xwork2.DefaultActionInvocation.createAction(DefaultActionInvocation.java:295)
    	com.opensymphony.xwork2.DefaultActionInvocation.init(DefaultActionInvocation.java:395)
    	com.opensymphony.xwork2.DefaultActionProxy.prepare(DefaultActionProxy.java:194)
    	org.apache.struts2.impl.StrutsActionProxy.prepare(StrutsActionProxy.java:63)
    	org.apache.struts2.impl.StrutsActionProxyFactory.createActionProxy(StrutsActionProxyFactory.java:37)
    	com.opensymphony.xwork2.DefaultActionProxyFactory.createActionProxy(DefaultActionProxyFactory.java:58)
    	org.apache.struts2.dispatcher.Dispatcher.serviceAction(Dispatcher.java:554)
    	org.apache.struts2.dispatcher.ng.ExecuteOperations.executeAction(ExecuteOperations.java:81)
    	org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter.doFilter(StrutsPrepareAndExecuteFilter.java:99)
    note The full stack trace of the root cause is available in the Apache Tomcat/6.0.29 logs.
    ====解决:

    <listener>
      	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
      </listener>
      <context-param>
      	<!-- ContextLoaderListener 父类里-->
      	<param-name>contextConfigLocation</param-name>
    <!--   	 <param-value>classpath:applicationContext.xml</param-value> -->
    <!-- 报错:service 创建失败。==######=原因:classpath只能读取src目录下的配置文件,【classpath*】:还可以读取jar包中的配置文件
       	 <param-value>classpath:applicationContext-*.xml</param-value> -->
    
      	 <param-value>classpath*:applicationContext-*.xml</param-value>
      	 
      </context-param>



    展开全文
  • _amaze! 转载于:https://www.cnblogs.com/luohaonan/p/11271062.html
  • 在不拆分项目的情况下,我们是通过扫mapper所在的路径,去实例化Dao的,然而当擦hi分过后,由于是连个项目,路径是找不到的,这种情况下,之前的dataSource和sqlSessionFactory以及包的路径, 我们需要做的是Dao层...
  • 本篇目录结构开胃小菜入戏时刻注意雷区脱坑指南最后说两句 开胃小菜 今天我要狠狠diss Maven官方(真的各位,...长话短说, 其实就是eclipse使用maven多模块拆分的时候 遇到的的一堆坑. 入戏时刻 注意, 我上面提到两个关
  • 错误信息如下: [2012-10-21 22:29:30]ERROR org.springframework.web.context.ContextLoader(line:220) -Context initialization failed org.springframework.beans.factory.BeanCreationException: Error ...
  • 文章目录Maven拆分聚合思想一、问题引入二、maven的聚合思想2.1 工程与模块的概念2.1.1 工程和模块的区别三、具体示例 Maven拆分聚合思想 一、问题引入 在我们前面创建SSM整合案例里面,可以看出我们普通项目中...
  • 一个大项目经常要拆分成多个小模块分开打包,Maven是可以支持模块拆分的。可以包含(父模块即项目包含子模块),也可以并行(父模块和子模块是平级的)。推荐用包含方式,更清晰,更简单一些。首先建个空项目,只要个pom...
  • 最近工作遇到Maven单项目拆分多模块项目问题,故简作记录相关分支如下:Master(线上分支)Split(拆分分支)UnionDev(团队成员同步开发合并分支)Dev1(团队成员同步开发分支1)Dev2(团队成员同步开发分支2)... ...拆分...
  • 首先maven拆分模块的启动方式有3种 1.直接使用父工程中的tomcat插件执行 2.使用idea配置tomcat,启动(需要本地安装tomcat) 3.通过web模块使用tomcat插件运行(问题就是出在这里)。因为模块没子模块的信息,需要使用...
  • maven工程拆分的ssm框架(方便代码重用):父工程提供pom.xml文件,子工程包括ssm_web、ssm_service、ssm_dao三个子工程,其中ssm_web的pom.xml文件中导入ssm_service的依赖,ssm_service的pom.xml中导入ssm_dao的依赖.
  • 模块拆分Maven经常使用的功能,简单梳理一下如何使用Maven进行多模块拆分,只做归纳总结,网上资料很多,不再一步一步实际创建和部署。建立Maven多模块项目一个简单的Java Web项目,Maven模块结构是这样的:上述...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,310
精华内容 524
关键字:

maven拆分