SpringBoot填坑系列---XML方式配置数据库

本次只是简单的运用SpringBoot搭建框架,对其原理并不做深入的探究

1.POM文件

  1 <?xml version="1.0" encoding="UTF-8"?>
  2 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4     <modelVersion>4.0.0</modelVersion>
  5
  6     <groupId>com.hxyz</groupId>
  7     <artifactId>media</artifactId>
  8     <version>0.0.1-SNAPSHOT</version>
  9     <packaging>jar</packaging>
 10
 11     <name>media</name>
 12     <description>Demo project for Spring Boot</description>
 13
 14     <parent>
 15       <groupId>org.springframework.boot</groupId>
 16       <artifactId>spring-boot-starter-parent</artifactId>
 17       <version>1.4.0.RELEASE</version>
 18       <relativePath/> <!-- lookup parent from repository -->
 19    </parent>
 20
 21    <properties>
 22       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 23       <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
 24       <java.version>1.8</java.version>
 25       <mybatis.version>3.2.2</mybatis.version>
 26    </properties>
 27
 28    <dependencies>
 29     <dependency>
 30         <groupId>org.springframework.boot</groupId>
 31         <artifactId>spring-boot-starter-web</artifactId>
 32     </dependency>
 33     <dependency>
 34         <groupId>mysql</groupId>
 35         <artifactId>mysql-connector-java</artifactId>
 36     </dependency>
 37     <!-- mybatis -->
 38     <dependency>
 39         <groupId>org.mybatis</groupId>
 40         <artifactId>mybatis</artifactId>
 41         <version>${mybatis.version}</version>
 42     </dependency>
 43     <dependency>
 44         <groupId>org.mybatis</groupId>
 45         <artifactId>mybatis-spring</artifactId>
 46         <version>1.2.0</version>
 47     </dependency>
 48
 49     <dependency>
 50             <groupId>org.springframework.boot</groupId>
 51             <artifactId>spring-boot-starter</artifactId>
 52         </dependency>
 53         <dependency>
 54             <groupId>org.springframework.data</groupId>
 55             <artifactId>spring-data-commons</artifactId>
 56         </dependency>
 57         <!-- connection pool -->
 58         <dependency>
 59             <groupId>org.springframework</groupId>
 60             <artifactId>spring-jdbc</artifactId>
 61         </dependency>
 62         <dependency>
 63             <groupId>org.apache.tomcat</groupId>
 64             <artifactId>tomcat-jdbc</artifactId>
 65         </dependency>
 66         <dependency>
 67             <groupId>mysql</groupId>
 68             <artifactId>mysql-connector-java</artifactId>
 69         </dependency>
 70        <dependency>
 71             <groupId>com.fasterxml.jackson.core</groupId>
 72             <artifactId>jackson-databind</artifactId>
 73             <version>2.7.0</version>
 74         </dependency>
 75         <dependency>
 76             <groupId>net.sf.json-lib</groupId>
 77             <artifactId>json-lib</artifactId>
 78             <version>2.4</version>
 79             <classifier>jdk15</classifier>
 80         </dependency>
 81         <dependency>
 82             <groupId>com.fasterxml.jackson.module</groupId>
 83             <artifactId>jackson-module-jaxb-annotations</artifactId>
 84             <version>2.7.0</version>
 85         </dependency>
 86          <dependency>
 87             <groupId>net.sf.json-lib</groupId>
 88             <artifactId>json-lib</artifactId>
 89             <version>2.4</version>
 90             <classifier>jdk15</classifier>
 91         </dependency>
 92         <dependency>
 93             <groupId>dom4j</groupId>
 94             <artifactId>dom4j</artifactId>
 95             <version>1.1</version>
 96         </dependency>
 97         <dependency>
 98             <groupId>org.apache.commons</groupId>
 99             <artifactId>commons-lang3</artifactId>
100             <version>3.1</version>
101         </dependency>
102         <dependency>
103             <groupId>org.codehaus.jackson</groupId>
104             <artifactId>jackson-mapper-asl</artifactId>
105             <version>1.9.13</version>
106         </dependency>
107         <dependency>
108             <groupId>org.codehaus.jackson</groupId>
109             <artifactId>jackson-core-asl</artifactId>
110             <version>1.9.13</version>
111         </dependency>
112     </dependencies>
113
114     <build>
115         <plugins>
116             <plugin>
117                 <groupId>org.springframework.boot</groupId>
118                 <artifactId>spring-boot-maven-plugin</artifactId>
119             </plugin>
120         </plugins>
121     </build>
122
123
124 </project>

2.通过MyBatis-generate自动生成实体类和mapper

3.配置XML文件

在resource下面新建applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:jee="http://www.springframework.org/schema/jee"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.0.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">
 <bean id="dataSource" class="org.apache.tomcat.jdbc.pool.DataSource" destroy-method="close">
        <!-- Connection Info -->
        <property name="driverClassName" value="${jdbc.driver}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />

        <!-- Connection Pooling Info -->
        <property name="maxActive" value="10" />
        <property name="maxIdle" value="50" />
        <property name="minIdle" value="0" />
        <property name="defaultAutoCommit" value="false" />
    </bean>
     <!-- MyBatis配置 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!-- 自动扫描entity目录, 省掉Configuration.xml里的手工配置 -->
        <property name="typeAliasesPackage" value="com.hxyz.media.entity" />
        <!-- 显式指定Mapper文件位置 -->
        <property name="mapperLocations" value="classpath:/mapper/*Mapper.xml" />
    </bean>
    <!-- 扫描basePackage下所有以@MyBatisRepository标识的 接口-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.hxyz.media.mapper" />
    </bean>
</beans>

在resource路径下新建application.properties

1 server.port=8089
2 jdbc.driver=com.mysql.jdbc.Driver
3 jdbc.url=jdbc:mysql://localhost:3306/
4 jdbc.username=jack
5 jdbc.password=123456

至此,我们的xml文件已经配置好了,我们可以写一个简单的控制器来测试下数据库是否已经连通

4.测试是否连通

1 public interface FactoryService {
2
3     public List<FactoryEntity> findFactory();
4
5 }
@Service
public class FactoryServiceImpl implements FactoryService{
    @Resource
    private FactoryEntityMapper factoryMaaper;

    @Override
    public List<FactoryEntity> findFactory() {
        FactoryEntityExample example=new FactoryEntityExample();
        Criteria createCriteria = example.createCriteria();
        List<FactoryEntity> selectByExample = factoryMaaper.selectByExample(example);
        return selectByExample;
    }

}
 1 @RestController
 2 @RequestMapping(value="front/factory")
 3 public class FactoryController {
 4     @Resource
 5     private FactoryService factoryService;
 6
 7     @RequestMapping(value="list")
 8     @ResponseBody
 9     public ResponseVo queryAll(){
10         ResponseVo responseVo=new ResponseVo();
11         List<FactoryEntity> factoryEntityList = factoryService.findFactory();
12         responseVo.setData(factoryEntityList);
13         return responseVo;
14
15     }
16
17
18 }

所以,我们猜一下,现在我请求下,数据会正常的返回么

我们现在请求下

http://localhost:8089/front/factory/list

返回的是

 1 Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type [com.hxyz.media.mapper.FactoryEntityMapper] found for dependency [com.hxyz.media.mapper.FactoryEntityMapper]: expected at least 1 bean which qualifies as autowire candidate for this dependency. Dependency annotations: {@javax.annotation.Resource(shareable=true, lookup=, name=, description=, authenticationType=CONTAINER, type=class java.lang.Object, mappedName=)}
 2     at org.springframework.beans.factory.support.DefaultListableBeanFactory.raiseNoMatchingBeanFound(DefaultListableBeanFactory.java:1406) ~[spring-beans-4.3.2.RELEASE.jar:4.3.2.RELEASE]
 3     at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:1057) ~[spring-beans-4.3.2.RELEASE.jar:4.3.2.RELEASE]
 4     at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:1019) ~[spring-beans-4.3.2.RELEASE.jar:4.3.2.RELEASE]
 5     at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.autowireResource(CommonAnnotationBeanPostProcessor.java:518) ~[spring-context-4.3.2.RELEASE.jar:4.3.2.RELEASE]
 6     at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.getResource(CommonAnnotationBeanPostProcessor.java:496) ~[spring-context-4.3.2.RELEASE.jar:4.3.2.RELEASE]
 7     at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor$ResourceElement.getResourceToInject(CommonAnnotationBeanPostProcessor.java:627) ~[spring-context-4.3.2.RELEASE.jar:4.3.2.RELEASE]
 8     at org.springframework.beans.factory.annotation.InjectionMetadata$InjectedElement.inject(InjectionMetadata.java:169) ~[spring-beans-4.3.2.RELEASE.jar:4.3.2.RELEASE]
 9     at org.springframework.beans.factory.annotation.InjectionMetadata.inject(InjectionMetadata.java:88) ~[spring-beans-4.3.2.RELEASE.jar:4.3.2.RELEASE]
10     at org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.postProcessPropertyValues(CommonAnnotationBeanPostProcessor.java:318) ~[spring-context-4.3.2.RELEASE.jar:4.3.2.RELEASE]
11     ... 34 common frames omitted

没有找到FactoryEntityMapper,但是我们明明是在xml中配置了mapperScannerConfigue

这是因为springboot在启动后并不会主动的去读取xml文件,只会根据类文件间的依赖去加载spring的bean类,所以springboot并没有发现xml中的配置

我们可以在启动类中添加

@ImportResource(locations = "classpath*:/applicationContext.xml")

完整的启动类如下

1 @ImportResource(locations = "classpath*:/applicationContext.xml")
2 @SpringBootApplication
3 //@SpringBootApplication(exclude = { DataSourceAutoConfiguration.class})
4 public class MediaApplication {
5
6     public static void main(String[] args) {
7         SpringApplication.run(MediaApplication.class, args);
8     }
9 }

这时我们再启动就可以返回数据了

 

时间: 2024-12-20 01:21:42

SpringBoot填坑系列---XML方式配置数据库的相关文章

Spring学习(五)bean装配详解之 【XML方式配置】

本文借鉴:Spring学习(特此感谢!) 一.配置Bean的方式及选择 配置方式 在 XML 文件中显式配置 在 Java 的接口和类中实现配置 隐式 Bean 的发现机制和自动装配原则 方式选择的原则 最优先:通过隐式 Bean 的发现机制和自动装配的原则. 基于约定优于配置的原则,这种方式应该是最优先的 好处:减少程序开发者的决定权,简单又不失灵活. 其次:Java 接口和类中配置实现配置 在没有办法使用自动装配原则的情况下应该优先考虑此类方法 好处:避免 XML 配置的泛滥,也更为容易.

跟着刚哥学习Spring框架--通过XML方式配置Bean(三)

Spring配置Bean有两种形式(XML和注解) 今天我们学习通过XML方式配置Bean 1. Bean的配置方式 通过全类名(反射)的方式   √ id:标识容器中的bean.id唯一. √ class:bean的全类名,通过反射的方式在IOC容器中创建Bean,所以要求Bean中必须有无参的构造器 2.依赖注入的方式 1)属性注入:通过setter方法注入Bean的属性值或依赖的对象 属性注入使用<Property>元素,使用name指定Bean的属性名称,使用value指定Bean的属

填坑系列:通过ESXi来配置IPMI

近日西安的天气很不错,可是看到从其他地方迁移来的主机在新环境下无法远程调试怪郁闷的,这就需要填坑,要不就会给后来者挖更大的坑. 今天遇到的坑是在IPMI的网络设置里面启用了VLAN标签之后,在新环境下IPMI直接失灵的问题. 由于时间原因,当时迁移的时候直接就断电了,很中国的理念是不——就是要快,先不看结果. 原有的环境是vSphere ESXi 4.1的操作系统,配置好IP之后可以通过vSphere Client去管理他,服务器是Supermicro的. 传统方式解决此问题需要还原出一个原有的

Android通过xml文件配置数据库

之前一段时间自己封装了两个数据库,一个是ORM数据库,另一个是事件流数据库,项目相应的地址如下: ORM数据库:https://github.com/wenjiang/SimpleAndroidORM 事件流数据库:https://github.com/wenjiang/EventStreamDB 有兴趣的人可以上去看看. 如果要讲这两个项目,一篇文章的篇幅是放不下的,所以就只是每篇都只讲一点点. 两个自己写的数据库都有一个必须用到的地方:在xml文件中配置数据库. 利用文件配置数据库在很多语言

LCT 填坑系列

清华冬令营 T1用了LCT 这个东西以前有写过 然而并不熟练 发现没了板子根本就不会写 只能填一填坑辣 BZOJ 2843 LCT 1 #include <bits/stdc++.h> 2 #define N 30010 3 #define ls c[x][0] 4 #define rs c[x][1] 5 using namespace std; 6 7 inline int read() 8 { 9 int x=0,f=1; char ch=getchar(); 10 while(ch&l

记录一次springboot整合mybatis的xml方式

java 1.8.0_231 因为刚开始学mybatis的时候图省事,看着xml这么多的配置文件就头大,然后就选择了使用注解的方法,但是后来做项目的时候,发现全注解的方式对于动态SQL语句的支持是真的一言难尽,于是这时候就想起了xml的好处,经过一番周折终于配置好了,这篇随笔就记录一下需要注意的地方 首先这个是项目目录,其中有一个result/Result是用于定义响应码code来负责前后端分离用的,这里先不做讨论 application.properties文件 mybatis.mapperL

Exchange 2013 SP1部署系列10:配置数据库高可用DAG

首先把Exchange Trusted Subsystem加入到Administrators组中,由于域控制器不在exchnge受信任的子系统里面,所以我们在域上把Exchange Trusted Subsystem加入到Administrators组.本来我们可以不用添加Exchange Trusted Subsystem组到Adminsitrators组,因为CAS服务器默认属于Exchange Trusted Subsystem组,而我们新建数据库可用性组,填入DAG名称.见证服务器,而见

在spring的配置中,基于注解方式是否比xml方式配置更好?——翻译

简短的回答就是“看情况了”.长篇大论来说(辩证的看待),每种方式都有利弊,通常来说,这取决于开发者选择最适合他们的策略.由于注解的定义方式,在其声明中提供了大量上下文,从而导致更短更简洁的配置.但是,XML的方式优势在于连接组件时解耦源代码或无需重新编译.一些开发人员更喜欢将配置连接靠近源头,而另一些则认为注释类不再是POJO,而且配置变得分散且难以控制. 不管是哪种方式,spring可以兼容两种风格并且混合使用都可以.值得提出的是,通过其JavaConfig选项,Spring允许以非侵入方式使

(填坑系列) 用aio写server与client进行通信的坑

最近闲来无事,就估摸着自己写个“服务注册中心”来玩,当然因为是个人写的,所以一般都是简洁版本. 代码地址在:https://gitee.com/zhxs_code/my-service-register.git 由于在处理与网络数据时,为了性能,想到用AIO来实验,结果发现AIO整个思路与之前的BIO,NIO都不一样.导致出现一些深坑,在此记录一下. (一)  AIO写的server端与client端,只能通信一次. 上代码: server端部分: 1 public class Register