Revisão básica de uso:
As instruções SQL são armazenadas em arquivos XML ou anotações Java. Um exemplo de mapeamento de Mabatis (que usa a interface Java e a anotação MYBATIS):
pacote org.mybatis.example; interface pública blogmapper {@select ("selecione * do blog onde id = #{id}") Blog SelectBlog (int id);}Exemplo de execução:
Blogmapper mapper = session.getmapper (blogmapper.class); blog blog = mapper.selectblog (101);
As instruções e mapeamentos SQL também podem ser externalizados para um arquivo XML:
<? xml versão = "1.0" Encoding = "utf-8"?> <! <select id = "selectblog" parameterType = "int" resultType = "Blog"> Selecione * do blog onde id = #{id} </select> </mapper>Você também pode usar a API Mybatis para executar declarações:
Blog blog = session.selectone ("org.mybatis.example.blogmapper.selectblog", 101);Para detalhes, consulte o manual do usuário fornecido pelo site do Mybatis.
Integrar -se à primavera
Mybatis se integra à estrutura da primavera. A Spring Framework permite que o Mybatis participe de transações de primavera, cria maperes e sessões mybatis e os injeta em outros feijões.
Aqui está um exemplo básico de configuração XML: um mapeador é criado e injetado no feijão "BlogService".
<bean id = "sqlsessionFactory"> <propriedade name = "dataSource" ref = "datasource" /> </i bean> <bean id = "blogmapper"> <names name = "sqlsessionFactory" ref = "sqlsessionFactory" /> <name = "mapperInterface" value = "Org.myb. id = "blogService"> <propriedade name = "blogmapper" ref = "blogmapper" /> </shean>
Agora, chamar Mybatis exige apenas chamar um feijão:
classe pública blogServiceImpl implementa blogService {Private Blogmapper Blogmapper; public void setBlogMapper (Blogmapper Blogmapper) {this.blogmapper = blogmapper; } public void doSomethingWithabLog (int blogId) {blog blog = blogmapper.SelectBlog (blogId); ...}} SQLSessionFactory
Cada aplicativo mybatis leva uma instância do objeto SQLSessionFactory como o núcleo. O próprio SQLSessionFactory é criado pelo SQLSessionFactoryBuilder. De um modo geral, em um aplicativo, um banco de dados corresponderá apenas a um SQLSessionFactory, por isso geralmente definimos o SQLSessionFactory como um padrão de singleton, ou o injetará na primavera, etc.
Os métodos para criar SQLSessionFactoryBuilder para criar SQLSessionFactory são:
Os principais parâmetros projetados por esses métodos são InputStream, Ambiente e Propriedades, onde o InputStream é um fluxo de entrada obtido no arquivo de configuração; O ambiente representa qual ambiente você está usando atualmente entre os muitos ambientes configurados no arquivo de configuração, incluindo fontes de dados e transações, e o ambiente padrão é usado por padrão; Usando propriedades, o MYBATIS carregará as propriedades ou arquivos correspondentes, que podem ser usados no arquivo de configuração.
Construção SQLSessionFactory de XML
SqlSession SQLSessionFactory = nulo; static {try {inputStream is = Resources.getResourceasStream ("config/mybatis_config.xml"); sqlSessionFactory = new SQLSessionFactoryBuilder (). Build (IS); } catch (ioexception e) {// TODO GATO GENERADO AUTOMENTADO BLOCO E.PRINTSTACKTRACE (); }} public static sqlSessionFactory getSqlSessionFactory () {return sqlSessionFactory; }
A seguir, é apresentada uma estrutura básica de arquivos de configuração:
O arquivo de configuração de Mybatis geralmente inclui as seguintes peças:
<ambientes default = "Development"> <Environment ID = "Development"> <transactionManager tipo = "JDBC" /> <DataSource Type = "Pooled"> <Propriedade Nome = "Driver" Value = "$ {JDBC.Driver}" /> <Nome da propriedade = "UR" Us) value = "$ {jdbc.username}"/> <propriedade name = "senha" value = "$ {jdbc.password}"/> </datasource> </ambiental Como o Mybatis pode configurar vários ambientes, você pode especificar um ambiente específico ao criar um SQLSessionFactory para criar um SQLSessionFactory. Se você não especificar, o ambiente padrão será usado.
TransactionManager
Existem dois tipos de gerentes de transação no mybatis (ou seja, tipo = ”[JDBC | gerenciado]”):
JDBC Esta configuração diretamente e simplesmente usa as configurações de comprometimento e reversão do JDBC. Ele depende de conexões obtidas de fontes de dados para gerenciar o escopo da transação.
A configuração gerenciada faz pouco. Ele nunca comete ou revira uma conexão. E permite que o contêiner gerencie todo o ciclo de vida de uma transação (como o contexto do servidor de aplicativos Spring ou JEE), ele fecha a conexão por padrão. No entanto, alguns contêineres não querem isso; portanto, se você precisar impedi -lo da conexão, defina a propriedade ClosConnection como false.
DataSource
O elemento DataSource usa a interface básica de fonte de dados JDBC para configurar recursos para objetos de conexão JDBC.
Muitos aplicativos MYBATIS configurarão a fonte de dados, conforme mostrado nos exemplos. No entanto, não é necessário. Você deve saber que, para facilitar o uso de carregamento preguiçoso, são necessárias fontes de dados.
Existem três tipos de fonte de dados embutidos (ou seja, tipo = "???"):
Não resfriado A implementação dessa fonte de dados é simplesmente abrir e fechar a conexão toda vez que for solicitada. É um pouco lento, o que é uma ótima opção para aplicativos simples, pois não requer conexões disponíveis oportunas. Diferentes bancos de dados também têm um desempenho diferente nisso; portanto, para alguns bancos de dados, não é importante configurar a fonte de dados, e essa configuração também está ociosa. A fonte de dados do tipo não gelada é usada apenas para configurar as 5 propriedades a seguir:
Como opção, você pode passar nas propriedades do driver do banco de dados. Para fazer isso, o prefixo do atributo começa com "Driver". Por exemplo:
driver.encoding = utf8
Isso passará o valor "UTF8" para passar pela codificação da propriedade ", que é passada para o driver do banco de dados pelo método DriverManager.GetConnection (URL, DriverProperties).
Ponched Esta é uma implementação do pool de conexão de fonte de dados para objetos de conexão JDBC, que são usados para evitar a conexão inicial necessária e o tempo de autenticação ao criar novas instâncias de conexão. Este é um método popular atualmente usado pelos aplicativos da Web para responder às solicitações rapidamente.
Além dos atributos acima (não resistentes), existem muitos atributos que podem ser usados para configurar a fonte de dados agrupada:
Entre eles, a configuração da fonte de dados JNDI requer apenas duas propriedades:
(1) A propriedade Initial_context é usada para encontrar o ambiente a partir do contexto inicial (ou seja, InitialContext.Lookup (Initial-Contexto). Esta é uma propriedade opcional. Se ignorado, a propriedade Data_Source será pesquisada novamente diretamente com o InitialContext como plano de fundo.
(2) data_source Este é o caminho que faz referência ao contexto do local da instância da fonte de dados. Ele procurará o ambiente retornado pela consulta Initial_context como plano de fundo. Se Initial_context não retornar o resultado, ele procurará o contexto inicial diretamente como ambiente.
Depois, há um mapeador. O Mapper é usado para mapear as instruções SQL. Primeiro, preciso dizer a Mybatis onde encontrar essas instruções SQL, ou seja, para especificar o local do recurso.
<Mappers> <Mapper Resource = "com/tiantian/mybatis/modelo/blogumapper.xml"/> </mappers>
Aqui está um arquivo de configuração simples que fiz durante o processo de teste:
<? xml versão = "1.0" coding = "utf-8"?> <! Resource = "Config/jdbc.properties"> </Properties> <typeAliases> <typeAlias alias = "blog" type = "com.tiantian.mybatis.model.blog"/> </typeAliases> <ambientes default = "desenvolvimento"> <ambiente = "desenvolvimento"> <transmanager name = "driver" value = "$ {jdbc.driver}" /> <propriedade name = "url" value = "$ {jdbc.url}" /> <names name = "nome de usuário" value = "$ {jdbc.username}" /> <name " /" /" /" $ {JDBC. <Mappers> <Mapper Resource = "com/tiantian/mybatis/model/blogmapper.xml"/> </mappers> </figuration>
Um arquivo de propriedade externa é importado para o arquivo de configuração acima. A introdução da propriedade no arquivo de configuração do mybatis pode ser incluída diretamente no elemento Propriedades, ou pode ser introduzido de fora usando o elemento Propriedades, ou pode ser passado como propriedades de parâmetro ao criar o SQLSessionFactory. Como as propriedades nos arquivos de configuração do MYBATIS podem ser introduzidas em tantos lugares, isso envolve uma questão prioritária e os mybatis os procurarão na seguinte ordem:
Primeiro, no arquivo de configuração, as propriedades no corpo do elemento de propriedades são lidas e, em seguida, as propriedades no arquivo de propriedades introduzidas de fora são lidas, o que substituirá as mesmas propriedades lidas antes. Finalmente, são lidas as propriedades nas propriedades aprovadas ao criar o SQLSessionFactory, o que também substituirá as mesmas propriedades antes.
Depois de ter o SQLSessionFactory, você receberá um SQLSession específico. No processo de usar Mybatis, todas as operações são inseparáveis do SQLSession, por isso é muito importante obter uma SQLSession. Além disso, o SQLSession não pode ser compartilhado e inseguro, portanto, você deve abrir um toda vez que precisar de SQLSession e depois fechá-lo depois de usá-lo.
SQLSession Session = sqlSessionFactory.opensssion ();
Os métodos de SQLSessionFactory Zhonghu District SqlSession são:
Suas principais diferenças são:
O método de abertura padrão não possui parâmetros, ele criará uma SQLSession com as seguintes características:
Executortype tem três valores:
As operações básicas da Mybatis são adicionar, excluir, modificar e verificar, a saber, inserir, excluir, atualizar e selecionar. Ao executar essas operações básicas, você pode usar diretamente o SQLSession para acessar o mapeamento no arquivo de configuração do mapeador ou pode usar a interface do mapeador correspondente ao arquivo de configuração do mapeador para executar operações, assumindo que os parâmetros e os valores de retorno dos métodos definidos na interface do mapper devem ser os mesmos que os parâmetros e retornar os valores definidos no MAPPER da MAPPPER. Além disso, ao usar a interface do mapeador, as instruções SQL correspondentes podem ser gravadas no arquivo de configuração do mapeador, ou elas podem ser marcadas diretamente nos métodos correspondentes na interface do mapeador usando as anotações correspondentes. Isso será visto no código de exemplo a seguir.
Aqui está uma série de códigos de exemplo:
Primeiro poste uma classe de ferramentas para obter o SQLSessionFactory:
importar java.io.ioException; importar java.io.inputStream; importar org.apache.ibatis.io.resources; importar org.apache.ibatis.session.sqlSessionFactory; importar org.apache.ibatis.session.sqlSessionFactoryBuilder; classe pública Util {private static sqlSessionFactory sqlSessionFactory = null; static {try {inputStream is = Resources.getResourceasStream ("config/mybatis_config.xml"); sqlSessionFactory = new SQLSessionFactoryBuilder (). Build (IS); } catch (ioexception e) {// TODO GATO GENERADO AUTOMENTADO BLOCO E.PRINTSTACKTRACE (); }} public static sqlSessionFactory getSqlSessionFactory () {return sqlSessionFactory; }}
Arquivo de configuração mybatis:
<? xml versão = "1.0" coding = "utf-8"?> <! Resource = "Config/jdbc.properties"> </Properties> <typeAliases> <typeAlias alias = "blog" type = "com.tiantian.mybatis.model.blog"/> </typeAliases> <ambientes default = "desenvolvimento"> <ambiente = "desenvolvimento"> <transmanager name = "driver" value = "$ {jdbc.driver}" /> <propriedade name = "url" value = "$ {jdbc.url}" /> <names name = "nome de usuário" value = "$ {jdbc.username}" /> <name " /" /" /" $ {JDBC. <Mappers> <Mapper Resource = "com/tiantian/mybatis/model/blogmapper.xml"/> </mappers> </figuration>
Blogmapper.xml
<? xml versão = "1.0" coding = "utf-8"?> <! namespace = "com.tiantian.mybatis.model.blogmapper"> <!-Adicionar gravação-> <insert id = "insertblog" parametertype = "blog"> inserir em t_blog (title, conteúdo, proprietário) (#{title},#{contenter},#{}) </quer) </quer) ParameterType = "int" resultType = "Blog"> Selecione * de t_blog onde id = #{id} </select> <!-modifique o registro-> <update id = "updateBlog" parameterType = "blog"> atualize t_blog set title = #}, title = # #{},},} #{} {} {} {} {{}} # # #{},} #{{} {}} # #{},},} {} {{}} # #{},}, e consulta vários registros para retornar o resultado é uma coleção. ResultType não é o tipo de coleção, mas o tipo contido na coleção-> <select id = "selectall" resultType = "Blog"> Selecione * de t_blog </leclect> <!-Fuzzy Query-> <select ID = "FuzzyQuery" ResultType = "Blog" ParameterType = "Java.Lang.string" </select> <!-Excluir registro-> <delete id = "DeleteBlog" parameterType = "int"> excluir do t_blog onde id = #{id} </lete> </mapper>Algumas questões que devem ser observadas nas declarações de mapeamento do SQL:
Blog.java
pacote com.tiantian.mybatis.model; Blog da classe pública {private int id; título de sequência privada; conteúdo privado de string; Proprietário de cordas privadas; public int getId () {return id; } public void setId (int id) {this.id = id; } public string gettitle () {return título; } public void Settitle (título da string) {this.title = title; } public string getContent () {return content; } public void setContent (String content) {this.content = content; } public string getwner () {return proprietário; } public void setrowner (proprietário da string) {this.owner = proprietário; } @Override public string tostring () {return "id:" + id + ", título:" + title + ", content:" + content + ", proprietário:" + proprietário; }}
Blogmapper.java
pacote com.tiantian.mybatis.model; importar java.util.list; importar org.apache.ibatis.annotações.delete; importar org.apache.ibatis.annotações.insert; importar org.apache.ibatis.annotações.Select; importar org.apache.ibatis.annotações.update; / *** As seguintes operações 1 grava SQL no arquivo de configuração, enquanto as operações 2 indicam diretamente a instrução SQL a ser executada com anotações* porque o nome completo do mapeador é o mesmo que o namespace no blogmapper.xml File, ele não pode ser incluído aqui* Use o Anotações para definir um mapa com o mesmo nome como o blogMapM. selectBlog (int id); @Select ("Selecione * de t_blog onde id = #{id}") public blog selectBlog2 (int id); public void InsertBlog (blog); @Insert ("inserir no t_blog (título, conteúdo, proprietário) valores (#{title},#{content},#{proprietário})") public void insertBlog2 (blog blog); public void updateblog (blog); @Update ("Atualize t_blog set title =#{title}, content =#{content}, proprietário =#{proprietário} onde id =#{id}") public void updateBlog2 (blog blog); public void DeleteBlog (int id); @Delete ("Excluir do t_blog onde id = #{id}") public void DeleteBlog2 (int id); Lista pública <blog> selectAll (); @Select ("Selecione * FROM T_BLOG") Lista pública <blog> selectall2 (); Lista pública <blog> fuzzyQuery (título da string); @Select ("Selecione * do t_blog onde o título como/"%/"#{title}/"%/") list <blog> fuzzyQuery2 (título da string); }
Test1.java
pacote com.tiantian.mybatis.test; importar java.util.list; importar org.apache.ibatis.session.SQLSession; importar org.junit.test; importar com.tiantian.mybatis.model.blog; importar com.tiantian.mybatis.util.util; / *** Esta série de operações está escrevendo SQL no arquivo de configuração e, em seguida, usando o SQLSession for Operação* @Author Andy**/ public class Test1 {/ *** Adicione gravação*/ @Test public void testInsertBlog () {sqlSession = util.GetSessqlSessFactory () optens (); Blog blog = novo blog (); blog.settitle ("chinês"); blog.setContent ("Quantos sonhos foram escondidos ao vento e chuva por cinco mil anos"); blog.setwner ("Daily"); session.insert ("com.tiantian.mybatis.model.blogmapper.insertblog", blog); session.Commit (); session.close (); } / *** Consulta um único 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 testUpDateBlog () {SqlSession Session = util.getSqlSessionFactory (). OpenSession (); Blog blog = novo blog (); blog.setId (7); // O ID do blog que precisa ser modificado blog.settitle ("chinês 2"); // modificar título blog.setContent ("rosto amarelo, olhos negros, sorriso inalterado"); // modificar conteúdo blog.setwner ("dia 2"); // modificar proprietário de sessão.UpDate ("com.tantian.mymym (" dia 2 "); // modificar o proprietário. blog); session.Commit (); session.close (); } / *** consulta todos os 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 nebulosa* / @Test public void testFuzzyQuery () {SqlSession Session = util.getSqlSessionFactory (). OpenSession (); String title = "China"; List <blog> blogs = session.SelectList ("com.tiantian.mybatis.model.blogmapper.fuzzyQuery", título); para (blog blog: blogs) system.out.println (blog); session.close (); } / *** Excluir 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
pacote com.tiantian.mybatis.test; importar java.util.list; importar org.apache.ibatis.session.SQLSession; importar org.junit.test; importar com.tiantian.mybatis.model.blog; import com.tiantian.mybatis.model.blogmapper; importar com.tiantian.mybatis.util.util; / *** Esta série de operações é escrever instruções SQL no arquivo de configuração,* e depois operar através da interface do mapeador correspondente* @Author Andy**/ public class Test2 {/ *** Adicionar registro*/ @Test public void testInsertBlog () {sqlsession = util.getSqlSesstifictory (. Blog blog = novo blog (); blog.settitle ("chinês"); blog.setContent ("Quantos sonhos foram escondidos ao vento e chuva por cinco mil anos"); blog.setwner ("Daily"); Blogmapper blogmapper = session.getmapper (blogmapper.class); blogmapper.insertblog (blog); session.Commit (); session.close (); } / *** Consulta um único 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 testUpDateBlog () {SqlSession Session = util.getSqlSessionFactory (). OpenSession (); Blog blog = novo blog (); blog.setId (9); // O ID do blog que precisa ser modificado blog.settitle ("chinês 2"); // modificar título blog.setContent ("rosto amarelo, olhos negros, sorriso inalterado"); // modificar conteúdo blog.setwner ("dia 2"); // modificar proprietários de blogmappper =.getMapper.getMapper. blogmapper.updateblog (blog); session.Commit (); session.close (); } / *** consulta todos os 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 nebulosa* / @Test public void testFuzzyQuery () {SqlSession Session = util.getSqlSessionFactory (). OpenSession (); Blogmapper blogmapper = session.getmapper (blogmapper.class); String title = "China"; List <blog> blogs = blogmapper.fuzzyQuery (título); para (blog blog: blogs) system.out.println (blog); session.close (); } / *** Excluir 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
pacote com.tiantian.mybatis.test; importar java.util.list; importar org.apache.ibatis.session.SQLSession; importar org.junit.test; importar com.tiantian.mybatis.model.blog; import com.tiantian.mybatis.model.blogmapper; importar com.tiantian.mybatis.util.util; / ** * Esta série de operações é realizada usando a interface do mapeador *, mas sua instrução SQL correspondente é definida no método correspondente no mapeador através da anotação correspondente * @Author Andy * */ public class Test3 {/ ** ** * registro */ @test public void testInsert () {sqlsess. Blogmapper blogmapper = session.getmapper (blogmapper.class); Blog blog = novo blog (); blog.settitle ("title2"); blog.setContent ("Content2"); blog.setwner ("proprietário2"); blogmapper.insertblog2 (blog); session.Commit (); session.close (); } / *** Encontre um único 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 (); } / *** Encontre vários registros, retorne o resultado como uma coleção* / @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 um registro* / @test public void testUpDate () {SqlSession Session = util.getSqlSessionFactory (). OpenSession (); Blogmapper blogmapper = session.getmapper (blogmapper.class); Blog blog = novo blog (); blog.setId (3); blog.settitle ("title3"); blog.setContent ("Content3"); blog.setwner ("proprietário3"); blogmapper.updateblog2 (blog); session.Commit (); session.close (); } / *** Excluir 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 (); }}Declaração de criação de tabela correspondente:
Criar tabela `t_blog` (` id` int (11) não null auto_increment, `title` Varchar (255) nulo padrão,` content` varchar (255) nulo padrão, `proprietário` varchar (50) nulo padrão, chave primária (` id`))