[Java] mybatis-4 mybatis与spring结合使用及原理解析

<dependencies>
 <dependency>
 <groupid>org.springframework</groupid>
 <artifactid>spring-context</artifactid>
 <version>5.0.8.release</version>
 </dependency>
 <dependency>
 <groupid>org.mybatis</groupid>
 <artifactid>mybatis-spring</artifactid>
 <version>2.0.0</version>
 </dependency>
 <dependency>
 <groupid>org.mybatis</groupid>
 <artifactid>mybatis</artifactid>
 <version>3.4.6</version>
 </dependency>
 <dependency>
 <groupid>mysql</groupid>
 <artifactid>mysql-connector-java</artifactid>
 <version>5.1.34</version>
 </dependency>
 <dependency>
 <groupid>org.springframework</groupid>
 <artifactid>spring-jdbc</artifactid>
 <version>5.0.8.release</version>
 </dependency>
 <dependency>
 <groupid>org.springframework</groupid>
 <artifactid>spring-core</artifactid>
 <version>5.0.8.release</version>
 </dependency>
</dependencies>

package com.config;
import org.mybatis.spring.sqlsessionfactorybean;
import org.mybatis.spring.annotation.mapperscan;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.componentscan;
import org.springframework.context.annotation.configuration;
import org.springframework.jdbc.datasource.drivermanagerdatasource;
import javax.sql.datasource;
@configuration
@mapperscan("com.dao")//注解 与xml<mybatis:scan base-package="org.mybatis.spring.sample.mapper" />
//注册包中递归搜索映射器
@componentscan("com")//注册bean
public class appconfig {
 @bean
 @autowired
 public sqlsessionfactorybean sqlsessionfactorybean(datasource datasource ){
 sqlsessionfactorybean sqlsessionfactorybean = new sqlsessionfactorybean();
 sqlsessionfactorybean.setdatasource(datasource);
 return sqlsessionfactorybean;
 }
 @bean
 public datasource getdatasource(){
 drivermanagerdatasource datasource = new drivermanagerdatasource();
 datasource.setdriverclassname("com.mysql.jdbc.driver");
 datasource.setusername("root");
 datasource.setpassword("110226wjwj");
 datasource.seturl("jdbc:mysql://localhost:3306/mybatis_wjw?useunicode=true&characterencoding=utf-8&usessl=false");
 return datasource;
 }
}

package com.dao;
import org.apache.ibatis.annotations.select;
import java.util.list;
import java.util.map;
public interface userdao {
 @select ("select * from t_user where tid =3")
 public list<map> query();
}

package com.service;
import com.dao.userdao;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.stereotype.service;
//spring注解中service与component意思差不多，区别在于component是中立注解，而service是业务逻辑层的注解
//@component
@service
public class userservice {
 @autowired
 userdao userdao;
 public void query(){
 system.out.println(userdao.query());
 }
}

package com.test;
import com.config.appconfig;
import com.service.userservice;
import org.springframework.context.annotation.annotationconfigapplicationcontext;
public class maintest {
 public static void main(string args[]){
 annotationconfigapplicationcontext acc = new annotationconfigapplicationcontext(appconfig.class);
 userservice us = acc.getbean(userservice.class);
 us.query();
 }
}

public <t> t selectone(string statement, object parameter) {
 list<t> list = this.selectlist(statement, parameter);
 if (list.size() == 1) {
  return list.get(0);
 } else if (list.size() > 1) {
  throw new toomanyresultsexception("expected one result (or null) to be returned by selectone(), but found: " + list.size());
 } else {
  return null;
 }
 }

public <e> list<e> selectlist(string statement, object parameter, rowbounds rowbounds) {
 list var5;
 try {
  mappedstatement ms = this.configuration.getmappedstatement(statement);
  var5 = this.executor.query(ms, this.wrapcollection(parameter), rowbounds, executor.no_result_handler);
 } catch (exception var9) {
  throw exceptionfactory.wrapexception("error querying database. cause: " + var9, var9);
 } finally {
  errorcontext.instance().reset();
 }
 return var5;
 }

protected set<beandefinitionholder> doscan(string... basepackages) {
 assert.notempty(basepackages, "at least one base package must be specified");
 set<beandefinitionholder> beandefinitions = new linkedhashset();
 string[] var3 = basepackages;
 int var4 = basepackages.length;
 for(int var5 = 0; var5 < var4; ++var5) {
  string basepackage = var3[var5];
  set<beandefinition> candidates = this.findcandidatecomponents(basepackage);
  iterator var8 = candidates.iterator();
  while(var8.hasnext()) {
  beandefinition candidate = (beandefinition)var8.next();
  scopemetadata scopemetadata = this.scopemetadataresolver.resolvescopemetadata(candidate);
  candidate.setscope(scopemetadata.getscopename());
  string beanname = this.beannamegenerator.generatebeanname(candidate, this.registry);
  if (candidate instanceof abstractbeandefinition) {
   this.postprocessbeandefinition((abstractbeandefinition)candidate, beanname);
  }
  if (candidate instanceof annotatedbeandefinition) {
   annotationconfigutils.processcommondefinitionannotations((annotatedbeandefinition)candidate);
  }
  if (this.checkcandidate(beanname, candidate)) {
   beandefinitionholder definitionholder = new beandefinitionholder(candidate, beanname);
   definitionholder = annotationconfigutils.applyscopedproxymode(scopemetadata, definitionholder, this.registry);
   beandefinitions.add(definitionholder);
   this.registerbeandefinition(definitionholder, this.registry);
  }
  }
 }
 return beandefinitions;
 }

public interface executor {
 resulthandler no_result_handler = null;
 int update(mappedstatement var1, object var2) throws sqlexception;
 <e> list<e> query(mappedstatement var1, object var2, rowbounds var3, resulthandler var4, cachekey var5, boundsql var6) throws sqlexception;
 <e> list<e> query(mappedstatement var1, object var2, rowbounds var3, resulthandler var4) throws sqlexception;
 <e> cursor<e> querycursor(mappedstatement var1, object var2, rowbounds var3) throws sqlexception;
 list<batchresult> flushstatements() throws sqlexception;
 void commit(boolean var1) throws sqlexception;
 void rollback(boolean var1) throws sqlexception;
 cachekey createcachekey(mappedstatement var1, object var2, rowbounds var3, boundsql var4);
 boolean iscached(mappedstatement var1, cachekey var2);
 void clearlocalcache();
 void deferload(mappedstatement var1, metaobject var2, string var3, cachekey var4, class<?> var5);
 transaction gettransaction();
 void close(boolean var1);
 boolean isclosed();
 void setexecutorwrapper(executor var1);
}