Revisión de uso básico:
Las declaraciones SQL se almacenan en archivos XML o anotaciones Java. Un ejemplo de mapeo mabatis (que utiliza la interfaz Java y la anotación mybatis):
paquete org.mybatis.example; public interfaz blogMapper {@select ("Seleccione * del blog donde id = #{id}") Blog selectlog (int id);}Ejemplo de ejecución:
BlogMapper mapper = session.getMapper (blogMapper.class); blog blog = mapper.selectblog (101);
Las declaraciones y asignaciones de SQL también se pueden externalizar a un archivo XML:
<? xml versión = "1.0" encoding = "utf-8"?> <! Doctype mapper public "-// mybatis.org//dtd mapper 3.0 // en" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"><mapper namespace = "org.mybatis.example.blogmapper"> <select id = "selectblog" parameterType = "int" resultype = "blog"> seleccionar * del blog donde id = #{id} </select> </ mapper>También puede usar la API MyBatis para ejecutar declaraciones:
Blog blog = session.selectone ("org.mybatis.example.blogmapper.selectblog", 101);Para obtener más detalles, consulte el manual del usuario proporcionado por el sitio web de MyBatis.
Integrarse con la primavera
MyBatis se integra con Spring Framework. El marco de primavera permite que MyBatis participe en transacciones de primavera, crea mapeadores y sesiones mybatis, y los inyecta en otros frijoles.
Aquí hay un ejemplo básico de configuración XML: se crea e inyecta un mapeador en el bean "BlogService".
<bean id = "sqlSessionFactory"> <<Property name = "dataSource" ref = "dataSource" /> < /bean> <bean id = "blogMapper"> <propiedad name = "sqlSessionFactory" ref = "sqlSessionFactory" /> <name de propiedad = "mapperinterface" valor = "org.mybatis.example.blogmapper" /> id = "BlogService"> <Property name = "BlogMapper" ref = "BlogMapper" /> </ Bean>
Ahora llamar a mybatis solo requiere llamar a un bean:
BlogServiceImpl de clase pública implementa BlogService {Blogmapper privado BlogMapper; public void setBlogMapper (blogMapper BlogMapper) {this.blogMapper = blogMapper; } public void DoSomethithAblog (int BlogID) {Blog Blog = BlogMapper.SelectBlog (BlogID); ...}} SqlsessionFactory
Cada aplicación mybatis toma una instancia del objeto SQLSessionFactory como el núcleo. SQLSessionFactory en sí es creado por SQLSessionFactoryBuilder. En términos generales, en una aplicación, una base de datos solo corresponderá a una SQLSessionFactory, por lo que generalmente definimos SQLSessionFactory como un patrón Singleton, o lo inyectamos a través de la primavera, etc.
Los métodos para crear SQLSessionFactoryBuilder para crear SQLSessionFactory son:
Los principales parámetros diseñados por estos métodos son InputStream, el entorno y las propiedades, donde InputStream es una secuencia de entrada obtenida del archivo de configuración; El entorno representa qué entorno está utilizando actualmente entre los muchos entornos configurados en el archivo de configuración, incluidas las fuentes de datos y las transacciones, y el entorno predeterminado se usa de forma predeterminada; Usando propiedades, MyBatis cargará las propiedades o archivos correspondientes, que se pueden usar en el archivo de configuración.
Construyendo SQLSessionFactory de XML
privado sqlsessionFactory sqlSessionFactory = null; static {try {inputStream is = recursos.getResourceasStream ("config/mybatis_config.xml"); sqlSessionFactory = new SqlSessionFactoryBuilder (). Build (is); } Catch (ioException e) {// tODO Auto Generated BLOCK E.PrintStackTRace (); }} public static sqlSessionFactory getsqlSessionFactory () {return sqlSessionFactory; }
La siguiente es una estructura básica de los archivos de configuración:
El archivo de configuración de MyBatis generalmente incluye las siguientes partes:
<Environmentos default = "desarrollo"> <entorno id = "desarrollo"> <transaccionManager type = "jdbc" /> <dataSource type = "agrupado"> <propiedad name = "controlador" valor = "$ {jdbc.driver}" /> <propiedad = "url" valor = "$ {jdbc.URL}" /> <name de propiedad = "username" value = "$ {jdB. /> <Property Name = "Password" Value = "$ {jdbc.password}"/> </dataSource> </entorno> </entornos> Dado que MyBatis puede configurar múltiples entornos, puede especificar un entorno específico al crear una SQLSessionFactory para crear una SQLSessionFactory. Si no lo especifica, se utilizará el entorno predeterminado.
managente de transacciones
Hay dos tipos de administradores de transacciones en MyBatis (es decir, tipo = "[JDBC | administrado]"):
JDBC Esta configuración directamente y simplemente usa la configuración de confirmación y reversión de JDBC. Se basa en las conexiones obtenidas de las fuentes de datos para administrar el alcance de la transacción.
La configuración administrada hace poco. Nunca se compromete ni revela una conexión. Y permite que el contenedor administre todo el ciclo de vida de una transacción (como el contexto de Spring o JEE Aplication Server), cierra la conexión de forma predeterminada. Sin embargo, algunos contenedores no quieren esto, por lo que si necesita detenerlo de la conexión, configure la propiedad CloseConnection en falso.
base de datos
El elemento DataSource utiliza la interfaz básica de origen de datos JDBC para configurar recursos para los objetos de conexión JDBC.
Muchas aplicaciones mybatis configurarán la fuente de datos como se muestra en los ejemplos. Sin embargo, no es necesario. Debe saber que para facilitar el uso de la carga perezosa, las fuentes de datos son necesarias.
Hay tres tipos de fuente de datos incorporados (es decir, type = "???"):
Sin calar la implementación de esta fuente de datos es simplemente abrir y cerrar la conexión cada vez que se solicita. Es un poco lento, lo cual es una excelente opción para aplicaciones simples, ya que no requiere conexiones oportunas disponibles. Las diferentes bases de datos también funcionan de manera diferente en esto, por lo que para algunas bases de datos, no es importante configurar la fuente de datos, y esta configuración también está inactiva. La fuente de datos de tipo no resolada solo se usa para configurar las siguientes 5 propiedades:
Como opción, puede pasar las propiedades del controlador de la base de datos. Para hacer esto, el prefijo del atributo comienza con "controlador". Por ejemplo:
controlador.Encoding = UTF8
Esto pasará el valor "UTF8" para pasar la propiedad "Codificación", que se pasa al controlador de la base de datos a través del método Drivermanager.getConnection (URL, DriverProperties).
Agrupado Esta es una implementación del grupo de conexión de fuente de datos para objetos de conexión JDBC, que se utiliza para evitar la conexión inicial y el tiempo de autenticación necesarios al crear nuevas instancias de conexión. Este es un método popular que actualmente utiliza aplicaciones web para responder a las solicitudes rápidamente.
Además de los atributos anteriores (sin calar), hay muchos atributos que se pueden usar para configurar la fuente de datos agrupada:
Entre ellos, la configuración de la fuente de datos JNDI solo requiere dos propiedades:
(1) La propiedad inicial_context se usa para encontrar el entorno en el contexto inicial (es decir, inicialcontext.lookup (inicial-contexto). Esta es una propiedad opcional. Si se ignora, la propiedad data_source se buscará nuevamente directamente con inicialcontext como fondo.
(2) data_source Esta es la ruta que hace referencia al contexto de la ubicación de la instancia de fuente de datos. Buscará el entorno devuelto por la consulta inicial_context como fondo. Si inicial_context no devuelve el resultado, buscará el contexto inicial como el entorno directamente.
Luego hay un mapeador. Mapper se usa para mapear las declaraciones SQL. Primero, necesito decirle a MyBatis dónde encontrar estas declaraciones SQL, es decir, especificar la ubicación de los recursos.
<Mappers> <Mapper Resource = "Com/Tiantian/MyBatis/Model/BlogMapper.xml"/> </mappers>
Aquí hay un archivo de configuración simple que hice durante el proceso de prueba:
<? xml versión = "1.0" encoding = "utf-8"?> < resource = "config/jdbc.Properties"> </propiies> <PyyPealiases> <typealias = "blog" type = "com.tiantian.mybatis.model.blog"/> </typealiases> <entornos default = "desarrollo"> <entorno id = "desarrollo"> <transaccionManager typee = "jdbc"/> <dataSource typee = " name="driver" value="${jdbc.driver}" /> <property name="url" value="${jdbc.url}" /> <property name="username" value="${jdbc.username}" /> <property name="password" value="${jdbc.password}" /> </dataSource> </environment> </environments> <Mappers> <Mapper Resource = "Com/Tiantian/MyBatis/Model/BlogMapper.xml"/> </mappers> </figuration>
Un archivo de propiedad externa se importa al archivo de configuración anterior. La introducción de la propiedad en el archivo de configuración de MyBatis se puede incluir directamente en el elemento Propiedades, o se puede introducir desde el exterior utilizando el elemento Propiedades, o se puede pasar como propiedades de parámetros al crear SQLSessionFactory. Dado que las propiedades en los archivos de configuración de MyBatis se pueden introducir en tantos lugares, implica un problema de prioridad, y MyBatis los buscará en el siguiente orden:
Primero, en el archivo de configuración, se leen las propiedades en el cuerpo del elemento de propiedades, y luego se leen las propiedades en el archivo de propiedades introducido desde el exterior, que sobrescribirán las mismas propiedades que se leen antes. Finalmente, se leen las propiedades en las propiedades al que se crean SQLSessionFactory, que también sobrescribirán las mismas propiedades antes.
Después de tener el SQLSessionFactory, obtendrá una SQLSession específica. En el proceso de uso de MyBatis, cada operación es inseparable de SQLSession, por lo que es muy importante obtener una SQLSession. Además, SQLSession no se puede compartir y la inicio de hilo, por lo que debe abrir uno cada vez que necesite SQLSession y luego cerrarla después de usarla.
Sqlsession session = sqlSessionFactory.opensession ();
Los métodos de SQLSessionFactory Zhonghu District SQLSession son:
Sus principales diferencias son:
El método de apertura predeterminado no tiene parámetros, creará una SQLSession con las siguientes características:
Ejecutype tiene tres valores:
Las operaciones básicas de MyBatis son agregar, eliminar, modificar y verificar, a saber, insertar, eliminar, actualizar y seleccionar. Al realizar estas operaciones básicas, puede usar directamente SQLSession para acceder a la asignación en el archivo de configuración de Mapper, o puede usar la interfaz mapper correspondiente al archivo de configuración de mapper para realizar operaciones, suponiendo que los parámetros y los valores de retorno de los métodos definidos en la interfaz mapper deben ser los mismos que los parámetros y los valores de retorno definidos en el archivo de configuración de mapper. Además, cuando se usa la interfaz MAPPER, las declaraciones SQL correspondientes se pueden escribir en el archivo de configuración de Mapper, o pueden marcarse directamente en los métodos correspondientes en la interfaz mapper utilizando las anotaciones correspondientes. Esto se verá en el siguiente código de ejemplo.
Aquí hay una serie de códigos de ejemplo:
Primero publique una clase de herramientas para obtener SQLSessionFactory:
import java.io.ioException; import java.io.inputstream; importar org.apache.ibatis.io.resources; importar org.apache.ibatis.session.sqlsessionFactory; importar org.apache.ibatis.session.sqlsessionFactoryBuilder; clase pública utilizar {sqlsession factory sqlsessionFactory = null; static {try {inputStream is = recursos.getResourceasStream ("config/mybatis_config.xml"); sqlSessionFactory = new SqlSessionFactoryBuilder (). Build (is); } Catch (ioException e) {// tODO Auto Generated BLOCK E.PrintStackTRace (); }} public static sqlSessionFactory getsqlSessionFactory () {return sqlSessionFactory; }}
Archivo de configuración de MyBatis:
<? xml versión = "1.0" encoding = "utf-8"?> < resource = "config/jdbc.Properties"> </propiies> <PyyPealiases> <typealias = "blog" type = "com.tiantian.mybatis.model.blog"/> </typealiases> <entornos default = "desarrollo"> <entorno id = "desarrollo"> <transaccionManager typee = "jdbc"/> <dataSource typee = " name="driver" value="${jdbc.driver}" /> <property name="url" value="${jdbc.url}" /> <property name="username" value="${jdbc.username}" /> <property name="password" value="${jdbc.password}" /> </dataSource> </environment> </environments> <Mappers> <Mapper Resource = "Com/Tiantian/MyBatis/Model/BlogMapper.xml"/> </mappers> </figuration>
BlogMapper.xml
<? xml versión = "1.0" encoding = "utf-8"?> <! Doctype mapper public "-// mybatis.org//dtd mapper 3.0 // en" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace = "com.tiantian.mybatis.model.blogmapper"> <!-Agregar registro-> <insertar id = "insertblog" parametertype = "blog"> insertar en t_blog (title, content, propietario) valores (#{title},#{content},#{propietario}) </!-Query A Single Record-> <Select Id = " parametertype = "int" resultType = "blog"> select * de t_blog donde id = #{id} </select> <!-Modifique el registro-> <update id = "updateBlog" parametType = "blog"> uply t_blog set title = #{title}, content = #{content}, propietario = #} donde id = #{id} </title} consulta múltiples registros para devolver el resultado es una colección. ResultType no es el tipo de colección, sino el tipo contenido en la colección-> <select id = "selectall" resultType = "Blog"> seleccionar * de t_blog </select> <!-Fuzzy Query-> <select id = "FuzzyQuery" </select> <!-Eliminar registro-> <deletete id = "deletleglog" parametertype = "int"> eliminar de t_blog donde id = #{id} </elete> </mapper>Algunos problemas que deben tenerse en cuenta en las declaraciones de mapeo SQL:
Blog.java
paquete com.tiantian.mybatis.model; Blog de clase pública {private int id; título de cadena privada; Contenido de cadena privada; propietario de una cadena privada; public int getId () {return id; } public void setid (int id) {this.id = id; } public String gettitle () {Título de retorno; } public void settitle (título de cadena) {this.title = title; } public String getContent () {return content; } public void setContent (contenido de cadena) {this.content = content; } public String getOwner () {return propietario; } public void setOwner (propietario de cadena) {this.owner = propietario; } @Override public string toString () {return "id" id: " + id +", title: " + title +", content: " + content +", propietario: " + propietario; }}
Blogmapper.java
paquete com.tiantian.mybatis.model; import java.util.list; importar org.apache.ibatis.annotations.delete; importar org.apache.ibatis.annotations.insert; importar org.apache.ibatis.annotations.select; importar org.apache.ibatis.annotations.update; / *** Las siguientes operaciones 1 escriben SQL en el archivo de configuración, mientras que las operaciones 2 indican directamente que la instrucción SQL se ejecutará con anotaciones* porque el nombre completo del mapper es el mismo que el espacio de nombres en el archivo BlogMapper.xml, no se puede incluir aquí* Usar anotaciones para definir un mapa con el mismo nombre como el archivo de blogmapper.xml* @Author*/*/*/* Blog público SelectBlog (int id); @Select ("Seleccionar * de t_blog donde id = #{id}") Blog público selectblog2 (int id); public void InsertBlog (blog Blog); @Insert ("Insertar en t_blog (title, content, propietario) valores (#{title},#{content},#{propietario})") public void insertBlog2 (blog blog); public void UpdateBlog (blog de blog); @Update ("Update t_blog set title =#{title}, content =#{content}, propietario =#{propietario} donde id =#{id}") public void UpdateBlog2 (blog Blog); public void DeleteBlog (int id); @Delete ("Eliminar de t_blog donde id = #{id}") public void deleteBlog2 (int id); Lista pública <Blog> selectAll (); @Select ("Seleccionar * de T_Blog") Lista pública <Blog> selectAll2 (); Lista pública <Blog> FuzzyQuery (título de cadena); @Select ("Seleccionar * de T_Blog donde Título me gusta/"%/"#{Title}/"%/"") Lista pública <Blog> FuzzyQuery2 (título de cadena); }
Prueba1.java
paquete com.tiantian.mybatis.test; import java.util.list; importar org.apache.ibatis.session.sqlsession; importar org.junit.test; import com.tiantian.mybatis.model.blog; import com.tiantian.mybatis.util.util; / *** Esta serie de operaciones es escribiendo SQL en el archivo de configuración y luego utilizando SQLSession para la operación* @author andy**/ public class test1 {/ *** Agregar registro*/ @Test public void testInsertBlog () {sqlSession session = util.getSqlSessionFactory (). Blog blog = nuevo blog (); blog.settitle ("chino"); Blog.setContent ("¿Cuántos sueños se han ocultado en el viento y la lluvia durante cinco mil años"); Blog.SetOwner ("diario"); session.insert ("com.tiantian.mybatis.model.blogmapper.insertblog", blog); session.commit (); session.close (); } / *** consulta un solo registro* / @Test public void testSelectone () {sqlsession session = util.getSqlSessionFactory (). OpenSession (); Blog Blog = (Blog) Session.Selectone ("com.tiantian.mybatis.model.blogmapper.selectblog", 8); System.out.println (blog); session.close (); } / *** Modificar registro* / @Test public void topDateBlog () {sqlsession session = util.getSqlSessionFactory (). OpenSession (); Blog blog = nuevo blog (); Blog.SetId (7); // La identificación del blog que debe modificarse blog. session.update ("com.tiantian.mybatis.model.blogmapper.updateBlog", blog); session.commit (); session.close (); } / *** Consulta Todos los registros* / @Test public void testSelectall () {sqlsession session = util.getSqlSessionFactory (). OpenSession (); List <Blog> blogs = session.selectlist ("com.tiantian.mybatis.model.blogmapper.selectall"); para (Blog Blog: Blogs) System.out.println (blog); session.close (); } / *** consulta difusa* / @test public void testFuzzyQuery () {sqlsession session = util.getSqlSessionFactory (). OpenSession (); Title de cadena = "China"; List <Blog> blogs = session.selectlist ("com.tiantian.mybatis.model.blogmapper.fuzzyquery", título); para (Blog Blog: Blogs) System.out.println (blog); session.close (); } / *** Eliminar registro* / @test public void testDeleteBlog () {sqlsession session = util.getSqlSessionFactory (). OpenSession (); session.delete ("com.tiantian.mybatis.model.blogmapper.deleteBlog", 8); session.commit (); session.close (); }}
Test2.java
paquete com.tiantian.mybatis.test; import java.util.list; importar org.apache.ibatis.session.sqlsession; importar org.junit.test; import com.tiantian.mybatis.model.blog; import com.tiantian.mybatis.model.blogmapper; import com.tiantian.mybatis.util.util; / *** Esta serie de operaciones es escribir declaraciones SQL en el archivo de configuración,* y luego operar a través de la interfaz mapper correspondiente* @author andy**/ public Blog blog = nuevo blog (); blog.settitle ("chino"); Blog.setContent ("¿Cuántos sueños se han ocultado en el viento y la lluvia durante cinco mil años"); Blog.SetOwner ("diario"); BlogMapper BlogMapper = session.getMapper (blogMapper.class); BlogMapper.insertBlog (blog); session.commit (); session.close (); } / *** consulta un solo registro* / @Test public void testSelectone () {sqlsession session = util.getSqlSessionFactory (). OpenSession (); BlogMapper BlogMapper = session.getMapper (blogMapper.class); Blog Blog = BlogMapper.Selectblog (7); System.out.println (blog); session.close (); } / *** Modificar registro* / @Test public void topDateBlog () {sqlsession session = util.getSqlSessionFactory (). OpenSession (); Blog blog = nuevo blog (); Blog.SetId (9); // La identificación del blog que debe modificarse Blog. blogMapper.UpdateBlog (blog); session.commit (); session.close (); } / *** Consulta Todos los registros* / @Test public void testSelectall () {sqlsession session = util.getSqlSessionFactory (). OpenSession (); BlogMapper BlogMapper = session.getMapper (blogMapper.class); List <Blog> Blogs = BlogMapper.Selectall (); para (Blog Blog: Blogs) System.out.println (blog); session.close (); } / *** consulta difusa* / @test public void testFuzzyQuery () {sqlsession session = util.getSqlSessionFactory (). OpenSession (); BlogMapper BlogMapper = session.getMapper (blogMapper.class); Title de cadena = "China"; List <Blog> Blogs = BlogMapper.FuzzyQuery (título); para (Blog Blog: Blogs) System.out.println (blog); session.close (); } / *** Eliminar registro* / @test public void testDeleteBlog () {sqlsession session = util.getSqlSessionFactory (). OpenSession (); BlogMapper BlogMapper = session.getMapper (blogMapper.class); BlogMapper.DeleteBlog (10); session.commit (); session.close (); }}
Test3.java
paquete com.tiantian.mybatis.test; import java.util.list; importar org.apache.ibatis.session.sqlsession; importar org.junit.test; import com.tiantian.mybatis.model.blog; import com.tiantian.mybatis.model.blogmapper; import com.tiantian.mybatis.util.util; / ** * Esta serie de operaciones se realiza utilizando la interfaz mapper *, pero su declaración SQL correspondiente se define en el método correspondiente en el mapeador a través de la * anotación * @author andy * */ public class test3 {/ ** * new Record */ @test public void void () {sqlSession Session = Util.getSqlSession () (). BlogMapper BlogMapper = session.getMapper (blogMapper.class); Blog blog = nuevo blog (); Blog.settitle ("Title2"); Blog.setContent ("Content2"); Blog.SetOwner ("propietario2"); BlogMapper.insertBlog2 (blog); session.commit (); session.close (); } / *** Encuentre un solo registro* / @Test public void testSelectone () {sqlsession session = util.getSqlSessionFactory (). OpenSession (); BlogMapper BlogMapper = session.getMapper (blogMapper.class); Blog blog = blogMapper.selectblog2 (1); System.out.println (blog); session.close (); } / *** Encuentre múltiples registros, devuelva el resultado como una colección* / @test public void testSelectall () {sqlsession session = util.getSqlSessionFactory (). Opensession (); BlogMapper BlogMapper = session.getMapper (blogMapper.class); List <Blog> Blogs = BlogMapper.Selectall2 (); para (Blog Blog: Blogs) System.out.println (blog); session.close (); } / *** Modifique un registro* / @Test public void topUpDate () {sqlsession session = util.getSqlSessionFactory (). OpenSession (); BlogMapper BlogMapper = session.getMapper (blogMapper.class); Blog blog = nuevo blog (); Blog.SetId (3); blog.settitle ("title3"); Blog.SetContent ("Content3"); Blog.SetOwner ("propietario3"); blogMapper.UpdateBlog2 (blog); session.commit (); session.close (); } / *** Eliminar registro* / @test public void testDelete () {sqlsession session = util.getSqlSessionFactory (). OpenSession (); BlogMapper BlogMapper = session.getMapper (blogMapper.class); BlogMapper.DeleteBlog2 (5); session.commit (); session.close (); } @Test public void testFuzzyQuery () {sqlsession session = util.getSqlSessionFactory (). OpenSession (); BlogMapper BlogMapper = session.getMapper (blogMapper.class); List <Blog> Blogs = BlogMapper.FuzzyQuery2 ("China"); para (Blog Blog: Blogs) System.out.println (blog); session.close (); }}Declaración de creación de tabla correspondiente:
Crear tabla `t_blog` (` id` int (11) no nulo auto_incement, `title` varchar (255) predeterminado nulo,` content` varchar (255) predeterminado nulo, `propietario` varchar (50) predeterminado nulo, clave primaria (` id`))