Use Mybatis sozinho para gerenciar as coisas
Escrevi conteúdo relacionado no artigo de Mybatis. Aqui vou continuar escrevendo a demonstração mais simples. Vamos revisar o conteúdo de Mybatis antes. Primeiro, crie uma tabela e crie uma tabela de aluno simples:
Criar Table Student (Student_id int Auto_increntle, Student_name Varchar (20) Não NULL, Primária Chave (Student_id))
Crie a classe de entidade Student.java:
public class Student {private int studentId; private string studentName; public int getStudentId () {return studentId;} public void setStudentId (int studentId) {this.studentId = studentId;} public string getStudentName () {return studentName;} public void setStUnMame (studentName) {) {th That StudentName;} public void SetStUnnMe (StudentName) {) {th That StudentName; tostring () {return "Student {[StudentId:" + StudentId + "], [StudentName:" + StudentName + "]}";}} Para dizer mais, substituir o método ToString () para classes de entidade e imprimir cada (ou um atributo -chave) é uma abordagem recomendada. Em seguida, é config.xml, que contém a configuração básica do JDBC:
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-config.dtd"><configuration><typeAliases><typeAlias alias="Student" type = "org.xrq.Domain.student"/> </tyseTealiases> <ambientes default = "desenvolvimento"> <ambiente id = "desenvolvimento"> <transactionManager type = "jdbc"/> <dataSource type = "pooled"> <nome da propriedade = "driver =" com.mysql.jdbc.niver "> value = "jdbc: mysql: // localhost: 3306/teste"/> <propriedade name = "nome de usuário" value = "root"/> <propriedade name = "senha" value = "root"/> </dataSource> </ambiental
Depois, há student_mapper.xml, principalmente a instrução SQL específica:
<Mapper namespace = "studentmapper"> <resultado ResultMap = "StudentMap"> Selecione Student_id, Student_Name do Student; </leclect> <insert id = "insertStudent" useGeneratedKeys = "true" keyproperty = "studentId" parameterType = "Student"> inserir em Student_id, Student_id_name) ( #{studentId, jdbctype no student_id, Student_id_name) ( #{studentId, jdbctype no student_id, Student_id,) jdbctype = varchar}); </nsert> </mapper> Crie um mybatisutil.java, que é usado para criar alguns elementos básicos do mybatis. As classes subsequentes herdam esta classe:
classe pública mybatisutil {protegido SQLSessionFactory SSF; leitor de leitor estático protegido; static {try {reader = Resources.getResourCeasReader ("config.xml"); ssf = new sqlSessionFactoryBuilder (). SqlSession getSqlSession () {return ssf.opensssion ();}} Requisitos de desenvolvimento no nível da empresa:
1. Definição e implementação separadas
2. Desenvolvimento em camadas, geralmente DAO-> Serviço-> Controlador, não é descartado que mais uma camada/várias camadas ou menos uma camada é adicionada de acordo com a situação específica.
Então, primeiro escreva uma interface studentdao.java:
interface pública StudentDao {public list <vertudy> selectAllStudents (); public int InsertStudent (estudante);} Por fim, escreva um StudentDaoimpl.java para implementar esta interface. Observe que você deve herdar a classe Mybatisutil.java:
public class StudentDaoImpl estende o mybatisutil implementa o StudentDao {names de strings estática privada de strings. aluno) {sqlSession ss = getsqlSession (); int i = ss.insert (namespace + "insertStudent", aluno); // ss.commit (); ss.close (); retorno i;}} Escreva uma aula de teste:
classe pública StudentTest {public static void main (string [] args) {StudentDao studentdao = new StudentDaoimpl (); Student Student = new Student (); Student.SetStudentName ("Jack"); StudentDao.insertStudent (Student); System.out.println ("A Inserção Primária é:" estudante.getStudEntId ()); System.out.println ("---- Exibir alunos ------"); List <Ventul> StudentList = StudentDao.SelectAllStudents (); for (int i = 0, length = studentList.size (); i <comprimento; i ++) system.out.println (StudentList.get (i));}} O resultado deve estar vazio.
Eu disse que este exemplo é uma revisão e uma introdução ao nosso conteúdo hoje. A razão para isso está vazia é que a operação de inserção foi realizada, mas o mybatis não nos ajudará a enviar as coisas automaticamente; portanto, o que é exibido está naturalmente vazio. Nesse caso, você deve enviar manualmente a transação através do método Commit () de SQLSession, ou seja, abrir o comentário na linha 17 da classe StudentDaoimpl.java.
Para dizer mais, além da operação básica de inserção do Mybatis, este exemplo também tem a função de retornar o ID da chave primária inserida com base na inserção.
Em seguida, use o Spring para gerenciar as coisas do Mybatis, que também é a prática de gerenciamento de coisas mais usada no desenvolvimento de nível corporativo.
Gerencie as coisas mybatis com a primavera
Existem muitos artigos na Internet para explicar isso, e eu procurei muito, mas copiar e colar um ao outro ou não explicar o exemplo inteiro claramente. Com essa parte, tento explicar como usar a primavera para gerenciar as coisas do Mybatis.
Usando a primavera para gerenciar as coisas Mybatis, além dos feijões, contexto, núcleo, expressão e comuns necessários, também é necessário o seguinte conteúdo:
(1) Mybatis-spring-1.x.0.jar, este é um pacote de jar necessário para a integração da mola mybatis.
(2) Pool de conexão do banco de dados, DBCP e C3P0 podem ser usados. Estou usando o druida do Alibaba aqui
(3) JDBC, TX, AOP, JDBC é basicamente para não mencionar. TX e AOP são usados porque o suporte da Spring para o gerenciamento de coisas Mybatis é alcançado através da AOP
(4) AOPALLIANCE.
O pacote JAR acima será baixado usando o Maven. Aqueles que não usaram o MAVEN podem baixá -lo no CSDN. Você pode procurar por isso.
No arquivo de configuração config.xml de mybatis, a conexão JDBC pode ser removida e apenas a parte das tópelas pode ser retida:
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-config.dtd"><configuration><typeAliases><typeAlias alias="Student" type = "org.xrq.domain.student"/> </tysealiases> </figuration>
Deixe -me mencionar que o mybatis outro arquivo de configuração student_mapper.xml não precisa ser alterado. Em seguida, escreva o arquivo de configuração da primavera e eu o nomei Spring.xml:
<? xml versão = "1.0" coding = "utf-8"?> <beans xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns = "http: //www.springframew ork.org/schema/beans"xmlns:context="http://www.springframework.org/schema/Context"x mlns:tx="http://www.springframework.org/schema/tx"xmlns:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.2.xsdhttp://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schemaop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">< !-- Configuração da anotação-> <tx: anotation-driven transactent-manager = "transactionManager"/> <Context: anotation-Config/> <contextn: componente-sanger-scan "/<. Pool, use o druid do Alibaba-> <bean id = "DataSource" init-method = "init" destruir-method = "close"> <propriedade name = "url" value = "jdbc: mysql: // lochost: 3306/teste"/> <nome da propriedade "/"/") id = "sqlSessionFactory"> <propriedade name = "configLocation" value = "classPath: config.xml" /> <propriedade name = "mapperlocations" value = "classPath:*_ mapper.xml" /> <names name = "DataSource" ref = "datAsource" /> < /bengeting> <! name = "DataSource" ref = "DataSource"/> </shean> </sheans>
Isso inclui principalmente o gerenciador de transações e o pool de conexão do banco de dados.
Além disso, vemos que existe um SQLSessionFactory. Amigos que usaram Mybatis devem estar familiarizados com esta classe. É usado para configurar o ambiente Mybatis. Existem dois atributos ConfigLocation e Mapperlocations no SQLSessionFactory. Como o nome indica, representa a localização do arquivo de configuração e a localização do arquivo de mapeamento. Aqui, desde que o caminho seja configurado corretamente, o Spring carregará automaticamente esses dois arquivos de configuração.
Então, o que você deseja modificar é a classe de implementação da DAO. Neste momento, você não herdou mais a classe Mybatisutil anterior, mas herde o sqlsessionDaosupport.java de mybatis-spring-1.x.0.jar. O código específico é o seguinte:
@RepositoryPublic Class StudentDaoImpl estende SQLSessionDaosupport implementa StudentDao {names de sequência final estática privada (Studentmapper. selectAllStudents () {return getSqlSession (). SelectList (namespace + "selectAllStudents");} public int insertStudent (aluno aluno) {return getsqlSession (). insert (namespace + "insertstudent", aluno);}}}}}}}}}}}Duas anotações são usadas aqui, vamos falar sobre elas separadamente.
(1) @Repository, esta anotação é a mesma que @Component, @Controller e nossas anotações mais comuns do @Service, que podem declarar uma classe como um feijão de mola. Suas diferenças não estão em semântica específica, mas mais no posicionamento da anotação. Como mencionado anteriormente, os aplicativos em nível corporativo se concentram no conceito de desenvolvimento hierárquico, portanto essas quatro anotações semelhantes devem ser entendidas da seguinte forma:
• A anotação do repositório corresponde à camada de persistência, a saber, a camada DAO, que é usada para interagir diretamente com o banco de dados. De um modo geral, um método corresponde a uma instrução SQL específica
• Anotação de serviço@, que corresponde à camada de serviço, a saber, a camada de serviço, é a função de combinar instruções SQL únicas/múltiplas. Obviamente, se for simples, você chamará diretamente um método da camada DAO.
• Anotação do controlador@, que corresponde à camada de controle, ou seja, a camada de controle no modo de design do MVC. Sua função é receber solicitações de usuário, chamar serviços diferentes para obter dados de acordo com solicitações e combinar dados de acordo com os requisitos e envolvê -los de volta ao front -end.
• Anotação do componente@, que corresponde mais ao conceito de um componente. Se um feijão não souber que pertence a uma camada, você pode usar a anotação @component para anotar.
Isso também reflete uma das vantagens das anotações: ver o nome e saber o significado, ou seja, vendo essa anotação, você conhece aproximadamente a função dessa classe, ou seja, seu posicionamento em todo o projeto.
(2) @Resource, esta anotação e anotação @Autowired têm o mesmo significado, e ambas podem ser injetadas automaticamente com atributos de atributo. Como o SQLSessionFactory é o núcleo do Mybatis, ele foi declarado em primavera.xml. Portanto, o feijão com o ID "SQLSessionFactory" é injetado aqui através da anotação @Resource. Depois disso, o SQLSession pode ser obtido através do método getSQLSession () e os dados são adicionados, excluídos, modificados e verificados.
Finalmente, nada mais é do que escrever uma aula de teste para testar:
public classe StudentTest {public static void main (string [] args) {ApplicationContext AC = new ClassPathXMLApplicationContext ("spring.xml"); studentdao studentdao = (studentdao) ac.getBean ("StudentDaoImpl"); Student = New Student ();); studentdao.insertStudent (Student); System.out.println ("j =" + j + "/n");system.out.println("---Display Students ------"); List <ver-student> StudentList = StudentDao.SelectLallStudents (); for (int i = 0, length = studentList.size (); i <comprimento; i ++) system.out.println (StudentList.get (i));}} Como a classe StudentDaoimpl.java usa a anotação @Repository e não especifica um pseudônimo, o nome de StudentDaoimpl.java no recipiente da mola é "Primeira letra minúscula + letras restantes", isto é, "Studentdaoimpl".
Depois de executar o programa, você pode ver que o novo aluno foi atravessado no console, ou seja, o aluno foi inserido diretamente no banco de dados. Não houve comprometimento ou reversão em todo o processo. Todos eles foram implementados na primavera. Isso é para usar a primavera para gerenciar as coisas no mybatis.
PostScript
Este artigo analisa o uso básico de Mybatis e usa o Spring para gerenciar as coisas no Mybatis e fornece exemplos de código mais detalhados. Amigos necessitados podem estudá -lo de acordo com o código. Com base neste artigo, escreverei um artigo posteriormente para explicar a implementação do gerenciamento de coisas da Multi-Data entre tabelas únicas e várias tabelas. Esse requisito também é um requisito comum nas empresas e aplicativos.