精华内容
下载资源
问答
  • J2EE进阶(四)Spring配置文件详解

    万次阅读 热门讨论 2016-07-16 12:04:40
    J2EE进阶(四)Spring配置文件详解 Spring配置文件是用于指导Spring工厂进行Bean生产、依赖关系注入(装配)及Bean实例分发的"图纸"。Java EE程序员必须学会并灵活应用这份"图纸"准确地表达自己的"生产意图"。Spring...

    J2EE进阶(四)Spring配置文件详解

    前言

         Spring配置文件是用于指导Spring工厂进行Bean生产、依赖关系注入(装配)及Bean实例分发的"图纸"。Java EE程序员必须学会并灵活应用这份"图纸"准确地表达自己的"生产意图"。Spring配置文件是一个或多个标准的XML文档,applicationContext.xml是Spring的默认配置文件,当容器启动时找不到指定的配置文档时,将会尝试加载这个默认的配置文件。

         下面列举的是一份比较完整的配置文件模板,文档中各XML标签节点的基本用途也给出了详细的解释,这些XML标签节点在后续的知识点中均会用到,熟练掌握了这些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-2.5.xsd">  
        <!-- 定义使用C3P0连接池的数据源 -->  
        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">  
            <!-- 指定连接数据库的JDBC驱动 -->  
            <property name="driverClass">  
                <value>com.mysql.jdbc.Driver</value>  
            </property>
            <!-- 连接数据库所用的URL -->  
            <property name="jdbcUrl">  
                <value>jdbc:mysql://localhost:3306/eportal?useUnicode=  
                    true&characterEncoding=gbk</value>  
            </property>  
            <!-- 连接数据库的用户名 -->  
            <property name="user">  
                <value>root</value>  
            </property>  
            <!-- 连接数据库的密码 -->  
            <property name="password">  
                <value>root</value>  
            </property>  
            <!-- 设置数据库连接池的最大连接数 -->  
            <property name="maxPoolSize">  
                <value>20</value>  
            </property>  
            <!-- 设置数据库连接池的最小连接数 -->  
            <property name="minPoolSize">  
                <value>2</value>  
            </property>  
            <!-- 设置数据库连接池的初始化连接数 -->  
            <property name="initialPoolSize">  
                <value>2</value>  
            </property>  
            <!-- 设置数据库连接池的连接的最大空闲时间,单位为秒 -->  
            <property name="maxIdleTime">  
                <value>20</value>  
            </property>  
        </bean>  
        <!-- 定义Hibernate的SessionFactory -->  
        <bean id="sessionFactory" class="org.springframework.orm.  
    hibernate3.LocalSessionFactoryBean">  
            <!-- 依赖注入上面定义的数据源dataSource -->  
            <property name="dataSource" ref="dataSource" />  
            <!-- 注册Hibernate的ORM映射文件 -->  
            <property name="mappingResources">  
                <list>  
                    <value>com/eportal/ORM/News.hbm.xml</value>  
                    <value>com/eportal/ORM/Category.hbm.xml</value>  
                    <value>com/eportal/ORM/Memberlevel.hbm.xml</value>  
                    <value>com/eportal/ORM/Cart.hbm.xml</value>  
                    <value>com/eportal/ORM/Traffic.hbm.xml</value>  
                    <value>com/eportal/ORM/Newsrule.hbm.xml</value>  
                    <value>com/eportal/ORM/Merchandise.hbm.xml</value>  
                    <value>com/eportal/ORM/Admin.hbm.xml</value>  
                    <value>com/eportal/ORM/Orders.hbm.xml</value>  
                    <value>com/eportal/ORM/Cartselectedmer.hbm.xml</value>  
                    <value>com/eportal/ORM/Newscolumns.hbm.xml</value>  
                    <value>com/eportal/ORM/Member.hbm.xml</value>  
                </list>  
            </property>  
            <!-- 设置Hibernate的相关属性 -->  
            <property name="hibernateProperties">  
                <props>  
                    <!-- 设置Hibernate的数据库方言 -->  
                    <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>  
                    <!-- 设置Hibernate是否在控制台输出SQL语句,开发调试阶段通常设为true -->  
                    <prop key="show_sql">true</prop>  
                    <!-- 设置Hibernate一个提交批次中的最大SQL语句数 -->  
                    <prop key="hibernate.jdbc.batch_size">50</prop>  
                    <prop key="show_sql">50</prop>  
                </props>  
            </property>  
        </bean>  
        <!--定义Hibernate的事务管理器HibernateTransactionManager -->  
        <bean id="transactionManager"  
            class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
            <!-- 依赖注入上面定义的sessionFactory -->  
            <property name="sessionFactory" ref="sessionFactory" />  
        </bean>  
        <!--定义Spring的事务拦截器TransactionInterceptor -->  
        <bean id="transactionInterceptor"  
            class="org.springframework.transaction.interceptor.TransactionInterceptor">  
            <!-- 依赖注入上面定义的事务管理器transactionManager -->  
            <property name="transactionManager" ref="transactionManager" />  
            <!-- 定义需要进行事务拦截的方法及所采用的事务控制类型 -->  
            <property name="transactionAttributes">  
                <props>  
                    <!-- 以browse、list、load、get及is开头的所有方法采用只读型事务控制类型 -->  
                    <prop key="browse*">PROPAGATION_REQUIRED,readOnly</prop>  
                    <prop key="list*">PROPAGATION_REQUIRED,readOnly</prop>  
                    <prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>  
                    <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>  
                    <prop key="is*">PROPAGATION_REQUIRED,readOnly</prop>  
                    <!-- 所有方法均进行事务控制,如果当前没有事务,则新建一个事务 -->  
                    <prop key="*">PROPAGATION_REQUIRED</prop>  
                </props>  
            </property>  
        </bean>  
        <!-- 定义BeanNameAutoProxyCreatorf进行Spring的事务处理 -->  
        <bean class="org.springframework.aop.framework.autoproxy.    
    BeanNameAutoProxyCreator">  
            <!-- 针对指定的bean自动生成业务代理 -->  
            <property name="beanNames">  
                <list>  
                    <value>adminService</value>  
                    <value>columnsService</value>  
                    <value>newsService</value>  
                    <value>crawlService</value>  
                    <value>memberLevelService</value>  
                    <value>memberService</value>  
                    <value>categoryService</value>  
                    <value>merService</value>  
                    <value>cartService</value>  
                    <value>ordersService</value>  
                    <value>trafficService</value>  
                </list>  
            </property>  
            <!-- 这个属性为true时,表示被代理的是目标类本身而不是目标类的接口 -->  
            <property name="proxyTargetClass">  
                <value>true</value>  
            </property>  
            <!-- 依赖注入上面定义的事务拦截器transactionInterceptor -->  
            <property name="interceptorNames">  
                <list>  
                    <value>transactionInterceptor</value>  
                </list>  
            </property>  
        </bean>  
        <!-- 装配通用数据库访问类BaseDAOImpl -->  
        <bean id="dao" class="com.eportal.DAO.BaseDAOImpl">  
            <property name="sessionFactory" ref="sessionFactory" />  
        </bean>  
        <!-- 部署系统用户管理业务逻辑组件AdminServiceImpl -->  
        <bean id="adminService" class="com.eportal.service.AdminServiceImpl">  
            <property name="dao" ref="dao" />  
        </bean>  
        <!-- 部署新闻栏目管理业务逻辑组件ColumnsServiceImpl -->  
        <bean id="columnsService" class="com.eportal.service.ColumnsServiceImpl">  
            <property name="dao" ref="dao" />  
        </bean>  
        <!-- 部署订单管理业务逻辑组件OrderServiceImpl -->  
        <bean id="ordersService" class="com.eportal.service.OrderServiceImpl">  
            <property name="dao" ref="dao" />  
        </bean>  
        <!-- 部署流量统计业务逻辑组件TrafficServiceImpl -->  
        <bean id="trafficService" class="com.eportal.service.TrafficServiceImpl">  
            <property name="dao" ref="dao" />  
        </bean>  
        <!-- 部署Struts 2负责系统用户管理的控制器AdminAction -->  
        <bean id="adminAction" class="com.eportal.struts.action.  
    AdminAction" scope="prototype">  
            <property name="service" ref="adminService" />  
        </bean>  
        <!-- 部署Struts 2负责新闻栏目管理的控制器ColumnsAction -->  
        <bean id="columnsAction" class="com.eportal.struts.action.
    ColumnsAction" scope="prototype">  
            <property name="service" ref="columnsService" />  
        </bean>  
        <!-- 部署Struts 2负责新闻管理的控制器NewsAction -->  
        <bean id="newsAction" class="com.eportal.struts.action.  
    NewsAction" scope="prototype">  
            <property name="service" ref="newsService" />  
            <property name="columnsService" ref="columnsService" />  
        </bean>  
        <!-- 部署Struts 2负责新闻采集规则管理的控制器CrawlAction -->  
        <bean id="crawlAction" class="com.eportal.struts.action.  
    CrawlAction" scope="prototype">  
            <property name="service" ref="crawlService" />  
            <property name="columnsService" ref="columnsService" />  
        </bean>  
    </beans>

     

    美文美图

    展开全文
  • spring配置文件详解

    万次阅读 多人点赞 2018-09-07 08:55:39
    Spring配置文件是用于指导Spring工厂进行Bean生产、依赖关系注入(装配)及Bean实例分发的"图纸"。Java EE程序员必须学会并灵活应用这份"图纸"准确地表达自己的"生产意图"。Spring...

    转自:http://book.51cto.com/art/201004/193743.htm

    Spring配置文件是用于指导Spring工厂进行Bean生产、依赖关系注入(装配)及Bean实例分发的"图纸"。Java EE程序员必须学会并灵活应用这份"图纸"准确地表达自己的"生产意图"。Spring配置文件是一个或多个标准的XML文档,applicationContext.xml是Spring的默认配置文件,当容器启动时找不到指定的配置文档时,将会尝试加载这个默认的配置文件。

    在学会动手"绘制图纸"之前,先要学会"阅读图纸",熟能生巧讲的就是这个道理,"熟读唐诗三百首,不会作诗也会吟"。

    下面列举的是一份比较完整的配置文件模板,文档中各XML标签节点的基本用途也给出了详细的解释,这些XML标签节点在后续的知识点中均会用到,熟练掌握了这些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-2.5.xsd">  
        <!-- 定义使用C3P0连接池的数据源 -->  
        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">  
            <!-- 指定连接数据库的JDBC驱动 -->  
            <property name="driverClass">  
                <value>com.mysql.jdbc.Driver</value>  
            </property>  
            <!-- 连接数据库所用的URL -->  
            <property name="jdbcUrl">  
                <value>jdbc:mysql://localhost:3306/eportal?useUnicode=  
                    true&characterEncoding=gbk</value>  
            </property>  
            <!-- 连接数据库的用户名 -->  
            <property name="user">  
                <value>root</value>  
            </property>  
            <!-- 连接数据库的密码 -->  
            <property name="password">  
                <value>root</value>  
            </property>  
            <!-- 设置数据库连接池的最大连接数 -->  
            <property name="maxPoolSize">  
                <value>20</value>  
            </property>  
            <!-- 设置数据库连接池的最小连接数 -->  
            <property name="minPoolSize">  
                <value>2</value>  
            </property>  
            <!-- 设置数据库连接池的初始化连接数 -->  
            <property name="initialPoolSize">  
                <value>2</value>  
            </property>  
            <!-- 设置数据库连接池的连接的最大空闲时间,单位为秒 -->  
            <property name="maxIdleTime">  
                <value>20</value>  
            </property>  
        </bean>  
        <!-- 定义Hibernate的SessionFactory -->  
        <bean id="sessionFactory"  
            class="org.springframework.orm.  
    hibernate3.LocalSessionFactoryBean">  
            <!-- 依赖注入上面定义的数据源dataSource -->  
            <property name="dataSource" ref="dataSource" />  
            <!-- 注册Hibernate的ORM映射文件 -->  
            <property name="mappingResources">  
                <list>  
                    <value>com/eportal/ORM/News.hbm.xml</value>  
                    <value>com/eportal/ORM/Category.hbm.xml</value>  
                    <value>com/eportal/ORM/Memberlevel.hbm.xml</value>  
                    <value>com/eportal/ORM/Cart.hbm.xml</value>  
                    <value>com/eportal/ORM/Traffic.hbm.xml</value>  
                    <value>com/eportal/ORM/Newsrule.hbm.xml</value>  
                    <value>com/eportal/ORM/Merchandise.hbm.xml</value>  
                    <value>com/eportal/ORM/Admin.hbm.xml</value>  
                    <value>com/eportal/ORM/Orders.hbm.xml</value>  
                    <value>com/eportal/ORM/Cartselectedmer.hbm.xml</value>  
                    <value>com/eportal/ORM/Newscolumns.hbm.xml</value>  
                    <value>com/eportal/ORM/Member.hbm.xml</value>  
                </list>  
            </property>  
            <!-- 设置Hibernate的相关属性 -->  
            <property name="hibernateProperties">  
                <props>  
                    <!-- 设置Hibernate的数据库方言 -->  
                    <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>  
                    <!-- 设置Hibernate是否在控制台输出SQL语句,开发调试阶段通常设为true -->  
                    <prop key="show_sql">true</prop>  
                    <!-- 设置Hibernate一个提交批次中的最大SQL语句数 -->  
                    <prop key="hibernate.jdbc.batch_size">50</prop>  
                    <prop key="show_sql">50</prop>  
                </props>  
            </property>  
        </bean>  
        <!--定义Hibernate的事务管理器HibernateTransactionManager -->  
        <bean id="transactionManager"  
            class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
            <!-- 依赖注入上面定义的sessionFactory -->  
            <property name="sessionFactory" ref="sessionFactory" />  
        </bean>  
        <!--定义Spring的事务拦截器TransactionInterceptor -->  
        <bean id="transactionInterceptor"  
            class="org.springframework.transaction.interceptor.TransactionInterceptor">  
            <!-- 依赖注入上面定义的事务管理器transactionManager -->  
            <property name="transactionManager" ref="transactionManager" />  
            <!-- 定义需要进行事务拦截的方法及所采用的事务控制类型 -->  
            <property name="transactionAttributes">  
                <props>  
                    <!-- 以browse、list、load、get及is开头的所有方法采用只读型事务控制类型 -->  
                    <prop key="browse*">PROPAGATION_REQUIRED,readOnly</prop>  
                    <prop key="list*">PROPAGATION_REQUIRED,readOnly</prop>  
                    <prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>  
                    <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>  
                    <prop key="is*">PROPAGATION_REQUIRED,readOnly</prop>  
                    <!-- 所有方法均进行事务控制,如果当前没有事务,则新建一个事务 -->  
                    <prop key="*">PROPAGATION_REQUIRED</prop>  
                </props>  
            </property>  
        </bean>  
        <!-- 定义BeanNameAutoProxyCreatorf进行Spring的事务处理 -->  
        <bean  
            class="org.springframework.aop.framework.autoproxy.    
    BeanNameAutoProxyCreator">  
            <!-- 针对指定的bean自动生成业务代理 -->  
            <property name="beanNames">  
                <list>  
                    <value>adminService</value>  
                    <value>columnsService</value>  
                    <value>newsService</value>  
                    <value>crawlService</value>  
                    <value>memberLevelService</value>  
                    <value>memberService</value>  
                    <value>categoryService</value>  
                    <value>merService</value>  
                    <value>cartService</value>  
                    <value>ordersService</value>  
                    <value>trafficService</value>  
                </list>  
            </property>  
            <!-- 这个属性为true时,表示被代理的是目标类本身而不是目标类的接口 -->  
            <property name="proxyTargetClass">  
                <value>true</value>  
            </property>  
            <!-- 依赖注入上面定义的事务拦截器transactionInterceptor -->  
            <property name="interceptorNames">  
                <list>  
                    <value>transactionInterceptor</value>  
                </list>  
            </property>  
        </bean>  
        <!-- 装配通用数据库访问类BaseDAOImpl -->  
        <bean id="dao" class="com.eportal.DAO.BaseDAOImpl">  
            <property name="sessionFactory" ref="sessionFactory" />  
        </bean>  
        <!-- 部署系统用户管理业务逻辑组件AdminServiceImpl -->  
        <bean id="adminService" class="com.eportal.service.AdminServiceImpl">  
            <property name="dao" ref="dao" />  
        </bean>  
        <!-- 部署新闻栏目管理业务逻辑组件ColumnsServiceImpl -->  
        <bean id="columnsService" class="com.eportal.service.ColumnsServiceImpl">  
            <property name="dao" ref="dao" />  
        </bean>  
          
        <!-- 部署订单管理业务逻辑组件OrderServiceImpl -->  
        <bean id="ordersService" class="com.eportal.service.OrderServiceImpl">  
            <property name="dao" ref="dao" />  
        </bean>  
        <!-- 部署流量统计业务逻辑组件TrafficServiceImpl -->  
        <bean id="trafficService" class="com.eportal.service.TrafficServiceImpl">  
            <property name="dao" ref="dao" />  
        </bean>  
        <!-- 部署Struts 2负责系统用户管理的控制器AdminAction -->  
        <bean id="adminAction" class="com.eportal.struts.action.  
    AdminAction"  
            scope="prototype">  
            <property name="service" ref="adminService" />  
        </bean>  
        <!-- 部署Struts 2负责新闻栏目管理的控制器ColumnsAction -->  
        <bean id="columnsAction" class="com.eportal.struts.action.  
    ColumnsAction"  
            scope="prototype">  
            <property name="service" ref="columnsService" />  
        </bean>  
        <!-- 部署Struts 2负责新闻管理的控制器NewsAction -->  
        <bean id="newsAction" class="com.eportal.struts.action.  
    NewsAction"  
            scope="prototype">  
            <property name="service" ref="newsService" />  
            <property name="columnsService" ref="columnsService" />  
        </bean>  
        <!-- 部署Struts 2负责新闻采集规则管理的控制器CrawlAction -->  
        <bean id="crawlAction" class="com.eportal.struts.action.  
    CrawlAction"  
            scope="prototype">  
            <property name="service" ref="crawlService" />  
            <property name="columnsService" ref="columnsService" />  
        </bean>  
          
    </beans>   
    

     

     

    展开全文
  • MyBatis-Spring配置简单了解

    万次阅读 多人点赞 2015-05-11 11:10:10
    MyBatis-Spring配置简单了解SqlSessionFactoryBean配置在基本的 MyBatis 中,session 工厂可以使用 SqlSessionFactoryBuilder 来创建。而在 MyBatis-Spring 中,则使用 SqlSessionFactoryBean 来替代。示例&amp;lt...

    MyBatis-Spring配置简单了解

    SqlSessionFactoryBean配置

    在基本的 MyBatis 中,session 工厂可以使用 SqlSessionFactoryBuilder 来创建。而在 MyBatis-Spring 中,则使用 SqlSessionFactoryBean 来替代。

    示例

    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
      <property name="dataSource" ref="dataSource"/>
      <property name="mapperLocations">
        <array>
          <value>classpath:mapper/*.xml</value>
        </array>
      </property>
      <property name="typeAliasesPackage" value="com.isea533.mybatis.model"/>
      <property name="plugins">
        <array>
          <bean class="com.github.pagehelper.PageHelper">
            <property name="properties">
              <value>
                dialect=hsqldb
                reasonable=true
              </value>
            </property>
          </bean>
          <bean class="com.github.abel533.mapperhelper.MapperInterceptor">
            <property name="properties">
              <value>
                mappers=com.github.abel533.mapper.Mapper
                IDENTITY=MYSQL
                notEmpty=true
              </value>
            </property>
          </bean>
        </array>
      </property>
    </bean>

    dataSource属性

    该属性必须配置,多数据源时会有多个dataSource,同时也需要配置多个sqlSessionFactory来对应。

    mapperLocations属性

    配置该属性后,sqlSessionFactory会自动扫描该路径下的所有文件并解析。

    该路径支持多个,可以用,;\t\n进行分割。

    每一个路径都可以用直接的包路径,或者Ant风格的表达式。

    configLocation属性

    上面例子中并没有使用该属性,当SqlSessionFactoryBean提供的配置不能满足使用时,你可以使用mybatis-config.xml配置文件配置其他属性,然后通过configLocation属性指定该配置的路径,SqlSessionFactoryBean会使用该配置文件创建Configuration

    typeAliasesPackage属性

    该属性可以给包中的类注册别名,注册后可以直接使用类名,而不用使用全限定的类名(就是不用包含包名)。

    该属性可以配置多个,可以用,;\t\n进行分割。但是不支持Ant风格的路径

    plugins属性

    该属性可以配置MyBatis的拦截器,拦截器的配置顺序会影响拦截器的执行顺序。

    从上往下的拦截器,实际的执行顺序是这样,第一个拦截器会最后执行,最后一个会首先执行。

    然后出拦截器的顺序和配置的顺序一致,第一个最先返回,最后一个最后返回。

    就以上面的配置为例,一个简单的执行顺序图如下:

    执行顺序

    这些拦截器执行的顺序都是环绕型,不要简单理解为简单的顺序执行。

    从配置顺序来看,第一个配置的在最里面,后面的依次环绕上一个拦截器。

    MapperScannerConfigurer 配置

    为了代替手工使用 SqlSessionDaoSupport 或 SqlSessionTemplate 编写数据访问对象 (DAO)的代码,MyBatis-Spring 提供了一个动态代理的实现:MapperFactoryBean。这个类 可以让你直接注入数据映射器接口到你的 service 层 bean 中。当使用映射器时,你仅仅如调 用你的 DAO 一样调用它们就可以了,但是你不需要编写任何 DAO 实现的代码,因为 MyBatis-Spring 将会为你创建代理。

    示例

    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.isea533.mybatis.mapper"/>
        <property name="annotationClass" value="XXX"/>
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    </bean>

    一般用过的最多也就是这3个属性,实际情况下最常用的只有basePackage

    basePackage属性

    basePackage可以写多个,可以用,;\t\n进行分割。

    每一个路径都可以用直接的包路径,或者Ant风格的表达式。

    annotationClass属性

    该属性实际上就是起到一个过滤的作用,如果设置了该属性,那么MyBatis的接口只有包含该注解,才会被扫描进去。

    sqlSessionFactoryBeanName属性

    这个属性一般都用不到,只有当你配置多数据源的时候,这是会有多个sqlSessionFactory,你就需要通过该属性来指定哪一个sqlSessionFactory(值为SqlSessionFactoryBean <bean>配置中的id属性)。

    Ant通配符

    • ? 匹配任何单字符
    • * 匹配0或者任意数量的字符
    • ** 匹配0或者更多的目录

    举例

    • /project/*.a 匹配项目根路径下所有在project路径下的.a文件
    • /project/p?ttern 匹配项目根路径下 /project/pattern 和 /app/pXttern,但是不包括/app/pttern
    • /**/example 匹配项目根路径下 /project/example, /project/foow/example, 和 /example
    • /project/**/dir/file.* 匹配项目根路径下/project/dir/file.jsp, /project/foow/dir/file.html
    • /**/*.jsp 匹配项目根路径下任何的.jsp 文件

    最长匹配原则(has more characters)

    URL请求/project/dir/file.jsp,现在存在两个路径匹配模式/**/*.jsp和/project/dir/*.jsp,那么会根据模式/project/dir/*.jsp来匹配

    展开全文
  • 虽然spring早就推出...这里展示3种spring配置文件,来对比xml配置和java注解配置的区别,分别是spring\mvc\shiro的配置 先说总结: 对比2种配置方式会发现xml方法更繁琐(xml那恶心的头部约束),拿shiro来说...

    虽然spring早就推出java注解的方式配置框架,由于习惯了看xml所以一直没有去学习,然而最近需要学习springboot,为了平滑过渡,先被迫研究一下注解配置方式。

    这里展示3种spring配置文件,来对比xml配置和java注解配置的区别,分别是spring\mvc\shiro的配置

    先说总结:

    对比2种配置方式会发现xml方法更繁琐(xml那恶心的头部约束),拿shiro来说,配完spring-shiro.xml,往往还需要在mvc.xml中开启代理,启用aop,然后在web.xml中启动shiro的Filter

    而纯java配置只需一个类就能搞定,并且个人觉得可以更直观的看出bean的构造和依赖情况,又不依赖xsd文件

    所以貌似java配置方法越来越流行,而xml的方式逐渐在被替代

    话说回来现在springboot项目里似乎都已经放弃xml,要学习springboot的童鞋还是先习惯java配置方法吧(boot的配置还要高级,还要简单,感觉还是要先从基础的学起,免得直接看高级的一脸懵逼)

     

    一、 spring配置

    1、传统的spring.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:cache="http://www.springframework.org/schema/cache"
           xmlns:p="http://www.springframework.org/schema/p"
           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/cache
           http://www.springframework.org/schema/cache/spring-cache.xsd">
    
        <context:component-scan base-package="com.ssm"/>
    
        <context:property-placeholder location="classpath:jdbc.properties" ignore-unresolvable="true" />
    
        <!-- 数据源 -->
        <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
            <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql:///test?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
            <property name="username" value="${jdbc.username}"/>
            <property name="password" value="${jdbc.password}"/>
        </bean>
    
         <!--mybatis的SqlSession的工厂-->
        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="configLocation" value="classpath:mybatis.xml"/>
            <property name="dataSource" ref="dataSource"/>
            <property name="mapperLocations" value="classpath*:com/ssm/**/*-mapper.xml"/>
        </bean>
    
         <!--告诉mybatis去哪里找mapper.xml文件-->
        <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            <property name="basePackage" value="com.ssm.dao"/>
            <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        </bean>
    
        <!--事务配置-->
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <property name="dataSource" ref="dataSource"/>
        </bean>
        
        <!--启动事务-->
        <tx:annotation-driven transaction-manager="transactionManager" order="3"/>
    </beans>

     2、基于注解的java类配置方式:

    import org.apache.commons.dbcp2.BasicDataSource;
    import org.mybatis.spring.SqlSessionFactoryBean;
    import org.mybatis.spring.mapper.MapperScannerConfigurer;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.io.ClassPathResource;
    import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
    import org.springframework.jdbc.datasource.DataSourceTransactionManager;
    import org.springframework.transaction.PlatformTransactionManager;
    import org.springframework.transaction.annotation.EnableTransactionManagement;
    
    @Configuration
    @ComponentScan("com.demo")//启动spring扫描
    @PropertySource(value = {"classpath:jdbc.properties"}, ignoreResourceNotFound = true)//找不到配置文件则抛出异常
    @EnableTransactionManagement//启动事务
    public class SpringConfig {
    
        @Value("${jdbc.username}")
        private String username;
        @Value("${jdbc.password}")
        private String password;
    
        //数据源
        @Bean
        public BasicDataSource basicDataSource() {
            BasicDataSource dataSource = new BasicDataSource();
            dataSource.setDriverClassName("com.mysql.jdbc.Driver");
            dataSource.setUrl("jdbc:mysql:///test?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8");
            dataSource.setUsername(username);
            dataSource.setPassword(password);
            return dataSource;
        }
    
        //session工厂
        @Bean
        public SqlSessionFactoryBean sqlSessionFactoryBean(BasicDataSource dataSource) throws IOException {
            SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
            factoryBean.setDataSource(dataSource);
    
            // mapper location
            PathMatchingResourcePatternResolver pathResolver = new PathMatchingResourcePatternResolver();
            factoryBean.setMapperLocations(pathResolver.getResources("classpath*:com/demo/**/*-mapper.xml"));
    
            // config file
            factoryBean.setConfigLocation(new ClassPathResource("mybatis.xml"));
            return factoryBean;
        }
    
        //mapper扫描
        @Bean
        public MapperScannerConfigurer mapperScannerConfigurer() {
            MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
            mapperScannerConfigurer.setBasePackage("com.demo.dao");
            mapperScannerConfigurer.setSqlSessionFactoryBeanName("sqlSessionFactoryBean");
            return mapperScannerConfigurer;
        }
    
        //事务配置
        @Bean
        public PlatformTransactionManager transactionManager(BasicDataSource dataSource) {
            DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
            dataSourceTransactionManager.setDataSource(dataSource);
            return dataSourceTransactionManager;
        }
    
    }

    说明:

    2个配置文件内里都定义了数据源、mybatis的session工厂以及启用@Transantional的事务

    第一份是xml配置方法(这里忽略了web.xml),第二份是基于注解的纯java配置方法

    接下来看看mvc的配置:

     

    二、spring-mvc配置

    1、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:mvc="http://www.springframework.org/schema/mvc"
           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/mvc
           http://www.springframework.org/schema/mvc/spring-mvc.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context.xsd">
    
        <!-- 启动MVC配置 -->
        <mvc:annotation-driven/>
    
        <!-- 静态资源 -->
        <mvc:resources mapping="/static/**" location="/static/">
            <mvc:cache-control max-age="3600" cache-public="true"/>
        </mvc:resources>
        
        <!-- 启动mvc的自动扫描。Spring.xml可以不用扫描 -->
        <context:component-scan base-package="com.demo"/>
    
        
        <!-- 视图解析器 -->
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/WEB-INF/jsp/"/>
            <property name="suffix" value=".jsp"/>
            <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
        </bean>     
    
        <!--用来支持文件上传的multipart处理器-->
        <bean id="multipartResolver"
              class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
            <!--todo 可以通过配置参数控制上传文件的内容和大小-->
        </bean>
    </beans>

     然后是配置web.xml:

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <servlet>
        <servlet-name>mvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:mvc.xml</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>mvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

     

    2、java注解方式

    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.multipart.MultipartResolver;
    import org.springframework.web.multipart.commons.CommonsMultipartResolver;
    import org.springframework.web.servlet.ViewResolver;
    import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
    import org.springframework.web.servlet.config.annotation.EnableWebMvc;
    import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
    import org.springframework.web.servlet.view.InternalResourceViewResolver;
    import org.springframework.web.servlet.view.JstlView;
    
    @Configuration
    @EnableWebMvc//启动springMVC注解驱动 等价于xml 配置中的<mvc:annotation-driven/>
    @ComponentScan("com.demo")//扫描创建控制器类
    public class WebMvcConfig extends WebMvcConfigurerAdapter {
    
        @Bean//定义试图解析器
        public ViewResolver viewResolver(){
            InternalResourceViewResolver resolver = new InternalResourceViewResolver();
            resolver.setPrefix("/WEB-INF/jsp/");
            resolver.setSuffix(".jsp");
            resolver.setExposeContextBeansAsAttributes(true);
            resolver.setViewClass(JstlView.class);
            return resolver;
        }
    
        //静态资源配置
        @Override
        public void addResourceHandlers(ResourceHandlerRegistry registry) {
            registry.addResourceHandler("/static/**")
                    .addResourceLocations("/static/js")
                    .setCacheControl(CacheControl.maxAge(1, TimeUnit.HOURS).cachePublic());
        }
    
        /*静态资源交给默认的servlet
        @Override
        public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
            configurer.enable();
        }*/
    
        //文件上传组件
        @Bean
        public MultipartResolver multipartResolver() {
            return new CommonsMultipartResolver();
        }
    }

     再配个启动类(相当于web.xml中配置ContextLoadListener)

    继承了AbstractAnnotationConfigDispatcherServletInitializer的AppInitalizer的作用就类似web.xml中的ContextLoadListener,并且会在web项目运行初始化被自动发现并加载,这就是java config的魅力所在了,不管在哪里声明了配置了,只要继承了AbstractAnnotationConfigDispatcherServletInitializer,它就可以被自动加载。

     

    import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
    public class WebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
        @Override
        protected Class<?>[] getRootConfigClasses() {
            return new Class[]{RootConfig.class};//非SpringMVC上下文配置类,不需要就return null
        }
        @Override
        protected Class<?>[] getServletConfigClasses() {
            return new Class[]{WebMvcConfig.class};//SpringMVC上下文配置类
        }
        @Override
        protected String[] getServletMappings() {
            return new String[]{"/"};//dispatcher映射路径,一个string的列表,这里处理所有请求
        }
    //相当于web.xml中的
    //<servlet-mapping>
    //    <servlet-name>mvc</servlet-name>
    //    <url-pattern>/</url-pattern>
    //</servlet-mapping>
    }

    RootConfig,不需要的话在上面 WebAppInitializer 的 getRootConfigClasses() 里直接return null即可

    可以参考官方文档:

    https://docs.spring.io/spring/docs/current/spring-framework-reference/web.html#spring-web

     

    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.FilterType;
    import org.springframework.web.servlet.config.annotation.EnableWebMvc;
    @Configuration
    @ComponentScan(basePackages="com.ssm",excludeFilters={
            @ComponentScan.Filter(type= FilterType.ANNOTATION,value=EnableWebMvc.class)
    })
    public class RootConfig {
    //RootConfig.class的内容如下,它可以放在和AppInitializer同个目录下,主要用来配置spring的bean,这里只关注web项目的实现,所以暂时没有具体内容
    }

     

     

    三、shiro配置

    1、shiro.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">
    
    <!--shiroFilter 过滤器-->
    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <property name="securityManager" ref="securityManager"/>
        <property name="loginUrl" value="/login"/>
        <property name="successUrl" value="/hello"/>
        <property name="unauthorizedUrl" value="/fail"/>
        <property name="filters">
            <map>
                <entry key="authc" value-ref="formAuthenticationFilter"/>
                <!--自定义Filter,视需求-->
                <entry key="testAuth">
                     <bean class="com.yourpackage.AuthFilter"/>
                </entry>
            </map>
        </property>
        <property name="filterChainDefinitions" ref="shiroFilterChainDefinitions"></property>
    </bean>
    <!--权限过滤过滤器连定义 -->
    <bean name="shiroFilterChainDefinitions" class="java.lang.String">
        <constructor-arg>
            <value>
                /static/** = anon
                /login = authc
                /test = testAuth
            </value>
        </constructor-arg>
    </bean>
     
    <!--安全管理器 securityManager-->
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <property name="realm" ref="customRealm"/>
        <property name="cacheManager" ref="shiroCacheManager"/>
        <property name="sessionManager" ref="sessionManager"/>
        <property name="rememberMeManager" ref="rememberMeManager"/>
    </bean>
    
    <!--自定义系统认证域 Realm-->
    <bean id="customRealm" class="com.ssm.shiro.CustomRealm">
        <property name="credentialsMatcher" ref="credentialsMatcher"/>
    </bean>
    
    <!-- 凭证匹配器,数据库保存的密码是使用MD5算法加密的-->
    <bean id="credentialsMatcher" class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
        <property name="hashAlgorithmName" value="md5"/>
        <property name="hashIterations" value="1"/>
    </bean>
    
    <!-- 缓存管理器-->
    <bean id="shiroCacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">
    <property name="cacheManagerConfigFile" value="classpath:shiro-ehcache.xml"/>
    </bean>
    

     如果需要使用注解,还需要在mvc.xml中加入如下代码

    <!--开启aop,对类代理-->
    <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator">
        <property name="proxyTargetClass" value="true"/>
    </bean>
    <!--开启shiro注解支持-->
    <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
        <property name="securityManager" ref="securityManager"/>
    </bean>

    最后还要在web.xml中配置如下,启动shiro的Filter 

    <filter>
        <filter-name>shiroFilter</filter-name>
        <filter-class>
            org.springframework.web.filter.DelegatingFilterProxy
        </filter-class>
        <!--设置true由servlet容器控制filter的生命周期-->
        <init-param>
            <param-name>targetFilterLifecycle</param-name>
            <param-value>true</param-value>
        </init-param>
        <!--设置spring容器filter的bean id,如果不设置则找与filter-name一致的bean-->
        <!--<init-param>-->
            <!--<param-name>targetBeanName</param-name>-->
            <!--<param-value>shiroFilter</param-value>-->
        <!--</init-param>-->
    </filter>
    <filter-mapping>
        <filter-name>shiroFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    2、java方式:

    import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
    import org.apache.shiro.cache.ehcache.EhCacheManager;
    import org.apache.shiro.spring.LifecycleBeanPostProcessor;
    import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
    import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
    import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
    import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.DependsOn;
    
    @Configuration
    public class ShiroConfig {
    //在springboot中利用FilterRegistrationBean注册delegatingFilterProxy来启动shiro
    //    @Bean
    //    public FilterRegistrationBean delegatingFilterProxy(){
    //        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
    //        DelegatingFilterProxy proxy = new DelegatingFilterProxy();
    //        proxy.setTargetFilterLifecycle(true);
    //        proxy.setTargetBeanName("shiroFilter");
    //        filterRegistrationBean.setFilter(proxy);
    //        return filterRegistrationBean;
    //    }
    
        @Bean("shiroFilter")
        public ShiroFilterFactoryBean factory(DefaultWebSecurityManager securityManager) {
            ShiroFilterFactoryBean factoryBean = new ShiroFilterFactoryBean();
            factoryBean.setSecurityManager(securityManager);
            factoryBean.setLoginUrl("/login");
            factoryBean.setSuccessUrl("/user");
            factoryBean.setUnauthorizedUrl("/fail");
    
            //自定义Filter(视需求而定)
            Map<String, Filter> filters = factoryBean.getFilters();//等号后面也可以直接new LinkedHashMap();
            filters.put("testAuth", new YourFilter());
            factoryBean.setFilters(filters);
            //自定义url规则
            // http://shiro.apache.org/web.html#urls-
            Map<String, String> filterChainDefinitions = new LinkedHashMap<>();
            filterChainDefinitions.put("/login", "authc");
            filterChainDefinitions.put("/test", "testAuth");
            filterChainDefinitions.put("/static/**", "anon");
    
            factoryBean.setFilterChainDefinitionMap(filterChainDefinitions);
            return factoryBean;
        }
    
        @Bean("securityManager")
        public DefaultWebSecurityManager getManager() {
            DefaultWebSecurityManager manager = new DefaultWebSecurityManager();
            manager.setRealm(myShiroRealm());
    //        manager.setCacheManager(ehCacheManager());//注入缓存管理器,看需求
            /*
             * 关闭shiro自带的session,详情见文档
             * http://shiro.apache.org/session-management.html#SessionManagement-StatelessApplications%28Sessionless%29
             */
    //        DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
    //        DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
    //        defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
    //        subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
    //        manager.setSubjectDAO(subjectDAO);
            return manager;
        }
    
        @Bean
        public MyShiroRealm myShiroRealm() {
            MyShiroRealm myShiroRealm = new MyShiroRealm();
            myShiroRealm.setCredentialsMatcher(credentialsMatcher());
            return myShiroRealm;
        }
    
        @Bean("credentialsMatcher")
        public HashedCredentialsMatcher credentialsMatcher() {
            HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher();
            credentialsMatcher.setHashAlgorithmName("md5");
            credentialsMatcher.setHashIterations(5);
            return credentialsMatcher;
        }
        /**
         * 下面的代码是添加注解支持
         */
        @Bean
        @DependsOn("lifecycleBeanPostProcessor")
        public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
            DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
            // 强制使用cglib,防止重复代理和可能引起代理出错的问题
            // https://zhuanlan.zhihu.com/p/29161098
            defaultAdvisorAutoProxyCreator.setProxyTargetClass(true);
            return defaultAdvisorAutoProxyCreator;
        }
    
        @Bean("lifecycleBeanPostProcessor")
        public LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
            return new LifecycleBeanPostProcessor();
        }
    
        /**
         * 开启shiro aop注解支持. 使用代理方式; 所以需要开启代码支持;
         */
        @Bean
        public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(DefaultWebSecurityManager securityManager) {
            AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
            advisor.setSecurityManager(securityManager);
            return advisor;
        }
    
    //    @Bean
    //    public EhCacheManager ehCacheManager() {
    //        EhCacheManager cacheManager = new EhCacheManager();
            cacheManager.setCacheManagerConfigFile("classpath:ehcache.xml");
    //        return cacheManager;
    //    }
    }

    没有FilterRegistrationBean的话web.xml那段代码不能少,还得配置(暂时还没找到不通过FilterRegistrationBean注册

    DelegatingFilterProxy来启动Filter的方法)

    展开全文
  • spring 配置扫描多个包

    万次阅读 2017-09-27 17:59:59
    spring 配置扫描多个包
  • 1、通过《Spring Boot 全局配置文件》与《@Value 取赋值详解与 @ConfigurationProperties 对比》已经知道使用“@Value”注解与“@ConfigurationProperties”可以从全局配置文件“application.prope...
  • Spring配置文件总结

    万次阅读 多人点赞 2014-11-12 14:08:15
    Spring配置文件总结
  • Spring-Spring配置概述

    千次阅读 2017-07-16 05:01:17
    Spring容器高层视图 成功启动Spring容器的三个必要条件 Bean配置信息 基于XML的配置 Schema的配置格式 ...应用程序为Spring提供了完整的Bean配置信息 Bean的类都已经放到应用程序的类路径下 Spring
  • Spring学习笔记(四)--spring配置文件schema约束

    万次阅读 热门讨论 2018-01-16 15:37:46
    相关概念 在使用spring的配置文件时,新添加一个配置文件就需要添加相应的约束,一直没有研究过为什么要有这些约束,这些约束是干什么的。spring在启动的时候需要验证xml文档... 在项目中其中的一个spring配置文件约...
  • 目录 Spring中的方法 ...Spring Boot里面没有Spring配置文件,自己编写的配置文件,也不能自动识别; 想让Spring配置文件生效,加载@ImportResource标注配置类 项目结构如下: ...
  • Spring 配置数据库用户名密码加密

    万次阅读 2018-10-23 10:22:09
    对于一般的spring框架,经常要用到数据源配置,如果是用xml配置的话,一般都是如下形式   数据库用户名密码密文配置实现 现在的需求是不能在配置文件里明文配置数据库用户名和密码 新增密文属性文件 class...
  • 手动加载spring配置文件

    千次阅读 2018-08-22 15:32:10
    手动加载Spring配置文件有两个类,分别是ClassPathXmlApplication与FileSystemXmlApplicationContext; 两个类的区别: 1.ClassPathXmlApplication的使用方法 @Test public void testBean(){ //单配置文件方式...
  • 上一篇博客 Spring源码解析--Spring配置文件解析BeanDefinitionParserDelegate(四)中我们介绍了对Bean基本元素的解析处理器,接下来我们介绍一下Spring提供的NamespaceHandler的处理机制,简单来说就是命名空间...
  • Spring MVC和Spring配置AOP

    千次阅读 2016-01-09 12:48:56
    所以要想给Spring MVC的Controller添加AOP的话,得在Spring MVC的配置文件中配置,要想给Service和Repository添加AOP的话得在Spring配置文件中配置。 2.以一个例子说明,有人配置了Service层的事务AOP之后,事务...
  • applicationContext.xml如何配置 Spring配置文件
  • 工具:maven、spring framework(4.2.4.RELEASE) 示例代码:... spring framwork的核心功能是依赖注入、作为对象工厂 试验条件: maven spring framwork 4.2.4.RELEASE ...试验spring配置文...
  • Spring的配置方式 一.自动化装配Bean  注释:@ComponentScan(设置组件扫描的基础包) ...Spring配置的可选方案主要有三种: 在xml中进行显式配置; 在java中进行显式配置; 隐式的bean发现机制和自动装配;
  • Spring配置Servlet

    千次阅读 2011-09-24 20:01:49
    在讲之前,我们先来看看spring配置文件中为Servlet注入到底能不能成功。 首先,写一个随服务器启动的Servlet,Servlet中定义一个类变量,并定义set方法。随便在set方法中向控制台输出些东西,然后在doGet,doPost或...
  • Spring配置文件中的import

    千次阅读 2017-04-24 10:04:23
    在实际的项目开发中,我们往往会分为很多不同的包,如果遇见为不同的包都设置Spring配置文件的情况,都写在一个总的配置文件中,难免会造成配置文件内容臃肿,不易阅读的情况。 为了方便管理应用配置文件,推荐使用...
  • Spring(19):Spring 配置文件 拆分/组合/结构详解
  • 我们的工程一般在会跑在正式环境、测试...1、在spring配置文件中配置两种环境信息 2、在web.xml中配置使用哪种环境信息,tomcat启动的时候自动去加载对应的环境信息 spring.profiles.active dev
  • 1.Spring使用properties资源文件作为配置源,配置取classPath下面的. 工程中难免出现一些需要每次部署都需要...使用java的properties资源文件,将所有的配置参数都写到properties文件里面,使用${key}来在spring配置文件
  • Myeclipse中如何创建spring配置文件

    千次阅读 2017-06-05 15:01:53
    在Myeclipse中新创建的maven项目右键创建spring配置文件不能next,如何解决这个问题? 1.首先点击项目右键——》Myeclipse——》Add Spring Capabilities将spring添加到项目中 2.需要创建spring配置文件时,在项目...
  • Spring配置文件之引入命名空间

    千次阅读 2017-07-25 19:23:51
    如何为Spring配置文件引入命名空间是我在初接触Spring时有点头疼的问题。现在稍作整理(一)Spring配置文件的最简格式 <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi=...
  • spring 配置sqlite的方式

    千次阅读 2016-01-27 09:52:38
    sqlite作为一种嵌入式数据库越来越受欢迎,特别是在小型的项目中,下面介绍两种spring配置sqlite数据库的方式 第一种:配置在tomcat目录下  1、在tomcat根目录下创建dbs文件夹,将sqlite文件放到该目录下(暂定为...
  • Spring 配置文件报错 Cannot resolve class or package 明明有明确的类但是还会报错 解决:重新 mvn clean install spring 会一次加载所有在xml配置的bean
  • idea找不到spring配置文件

    千次阅读 2018-06-08 15:18:59
    idea找不到spring配置文件 近日学习mybaits和Spring的整合,看完视频,兴高采烈的动手做了起来。 可是在第一步就摔了跤,在application中引入数据库配置文件db.propertise的时候idea一直告诉我找不到文件。可是我...
  • spring配置文件中的import标签作用

    千次阅读 2017-02-20 14:10:43
    多个 Spring 配置文件通过 import 方式整合的话: 配置文件会先合并,后解析,也就是说,无论是命名空间还是配置的内容,都会合并处理。因为多个 Spring 配置文件最终会合并到一起(形成一个 ApplicationContext...
  • Eclipse编辑Spring配置文件xml时自动提示类class包名

    万次阅读 多人点赞 2017-04-14 22:25:47
    Spring2.0为例: 下载地址: Csdn: http://download.csdn.net/download/hh775313602/9812757 没积分的可以去百度网盘下载,我已共享: http://pan.baidu.com/s/1nv9bb1f 第一步,先查看下自己的Eclipse是...
  • spring 源码解读与设计详解:8 Spring配置文件的读取与容器装配详析 spring 源码解读与设计详解:8 Spring配置文件的读取与容器装配详析 spring 源码解读与设计详解:8 Spring配置文件的读取与容器装配详析 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 296,645
精华内容 118,658
关键字:

spring配置

spring 订阅