Usa mybatis solo para manejar las cosas
He escrito contenido relacionado en el artículo de MyBatis. Aquí continuaré escribiendo la demostración más simple. Revisemos el contenido de MyBatis antes. Primero, cree una tabla y cree una tabla de estudiante simple:
Cree Table Student (Student_ID int Auto_incement, Student_Name Varchar (20) No NULL, Key Primary (Student_ID)))
Crear clase de la entidad Student.java:
estudiante de clase pública {private int studentId; private string studentName; public int getStudentId () {return studentId;} public void setStudentId (int studentId) {this.studentIdD = studentId;} public String getStudentName () {return studentName;} public toString () {return "Student {[StudentId:" + StudentId + "], [StudentName:" + StudentName + "]}";}} Para decirlo más, anular el método ToString () para las clases de entidad e imprimir cada uno (o un atributo clave) es un enfoque recomendado. El siguiente es config.xml, que contiene la configuración básica de JDBC:
<? xml versión = "1.0" encoding = "utf-8"?> < type = "org.xrq.domain.student"/> </typealiases> <entornos default = "desarrollo"> <entorno id = "desarrollo"> <transaccionManager type = "jdbc"/> <dataSource type = "agrupado"> <propiedad = "controlador" valor = "com.mysql.jdbc.driver"/> <propiedad de propiedad = "url" Url "" Url "" Url " valor = "jdbc: mysql: // localhost: 3306/test"/> <Property name = "username" value = "root"/> <propiedad name = "contraseña" valor = "root"/> </dataSource> </entorno> </entornos> <mappers> <mapper recurse = "student_mapper.xml"/> <//mappers> </configuración>
Luego está Student_Mapper.xml, principalmente la instrucción SQL específica:
<mappper namespace = "studentMapper"> <resultmap type = "student" id = "studentmap"> <id columna = "student_id" propiedad = "studentID" jdbctype = "entero" /> <resultado columna = "student_name" propiedad = "studentN" jdbtbtype = "varchar" /> < /resultadoMap> <select id = "selectAllEnlame" resultMap = "StudentMap"> seleccione Student_ID, Student_Name de Student; </elect> <insert id = "insertStudent" useGeneratedKeys = "true" keyproperty = "studentid" parametterype = "estudiante"> Insert en student (student_id, student_nEns) Valores ( # #studentId, jdbctype = integer}, #{studentName,,,,, nombre, nombre, nombre) jdbctype = varchar}); </sert> </mapper> Cree un mybatisutil.java, que se usa para crear algunos elementos básicos de mybatis. Las clases posteriores heredan esta clase:
clase pública mybatisutil {protegido estático sqlSessionFactory ssf; proteged static lector lector; static {try {lector = recursos.getResourceasReader ("config.xml"); ssf = new sqlSessionFactoryBuilder (). Build (lector);} Catch (ioException e) {E.PrintstActAtre ();};} SqlSession getSqlSession () {return ssf.opensession ();}} Requisitos de desarrollo de nivel empresarial:
1. Definición e implementación separadas
2. Desarrollo en capas, generalmente DAO-> Servicio-> Controlador, no se descarta que una capa más/varias capas o una capa menos se agrega de acuerdo con la situación específica.
Entonces, primero escriba una interfaz Studentdao.Java:
Interfaz pública Estudiante de Studentdao {Lista pública <Sentor> SELECTALLSTUDENTS (); Public int InsertStudent (estudiante estudiante);} Finalmente, escriba un StudentDaoImpl.java para implementar esta interfaz. Tenga en cuenta que debe heredar la clase mybatisutil.java:
El estudiante de clase pública se extiende a MyBatisUtil implementa StudentDao {private static final String namespace = "StudentMapper."; public List <student> selectallStudents () {sqlsession ss = getsqlSession (); list <dietar> list = ss.selectList (namespace + "selectallStudents"); ss.clase (); estudiante) {sqlsession ss = getsqlSession (); int i = ss.insert (espacio de nombres + "insertStudent", estudiante); // ss.commit (); ss.close (); return i;}} Escribe una clase de prueba:
Public Class StudentTest {public static void main (string [] args) {studentdao studentdao = new studentDaoImpl (); estudiante estudiante = new student (); student.setStudentName ("jack"); studentdao.insertstudent (student); system.out.println ("La clave principal insertada es:" + + student.getStudentId ()); System.out.println ("---- Mostrar estudiantes ------"); List <Sentudent> StudentList = StudentDao.SelectallStudents (); para (int i = 0, longitud = studentList.size (); i <longitud; i ++) system.out.println (studentList.get (i));}} El resultado debe estar vacío.
He dicho que este ejemplo es tanto una revisión como una introducción a nuestro contenido hoy. La razón de esto está vacía es que la operación de inserción se ha realizado, pero MyBatis no nos ayudará a enviar las cosas automáticamente, por lo que lo que se muestra está naturalmente vacío. En este caso, debe enviar manualmente la transacción a través del método Commit () de SQLSession, es decir, abrir el comentario en la línea 17 de la clase StudentDaoImpl.java.
Para decirlo más, además de la operación básica de inserción de mybatis, este ejemplo también tiene la función de devolver la ID de clave primaria insertada sobre la base de la inserción.
A continuación, use la primavera para administrar las cosas de MyBatis, que también es la práctica de gestión de cosas más utilizada en el desarrollo de nivel empresarial.
Administre las cosas mybatis con primavera
Hay muchos artículos en Internet para explicar esto, y he buscado mucho, pero copiar y pegar entre sí o no explicar todo el ejemplo con claridad. A través de esta parte, trato de explicar cómo usar la primavera para administrar las cosas mybatis.
Utilizando la primavera para administrar las cosas mybatis, además de los frijoles de módulo necesarios, contexto, núcleo, expresión y registro de bienes comunes de Spring, también se requiere el siguiente contenido:
(1) MyBatis-Spring-1.x.0.Jar, este es un paquete jar necesario para la integración de primavera mybatis.
(2) Se pueden usar el grupo de conexión de la base de datos, DBCP y C3P0. Estoy usando el druida de Alibaba aquí
(3) JDBC, TX, AOP, JDBC es básicamente sin mencionar. TX y AOP se utilizan porque el soporte de Spring para MyBatis Thing Management se logra a través de AOP
(4) AOPALLIANCE.JAR, este es un paquete de jares necesario para usar AOP Spring
El paquete JAR de arriba se descargará usando Maven. Aquellos que no han usado Maven pueden descargarlo en CSDN. Puedes buscarlo.
En el archivo de configuración config.xml de myBatis, la conexión JDBC se puede eliminar y solo se puede conservar la parte de typealiases:
<? xml versión = "1.0" encoding = "utf-8"?> < type = "org.xrq.domain.student"/> </typealiases> </figuration>
Permítanme mencionar que myBatis otro archivo de configuración student_mapper.xml no es necesario cambiar. A continuación, escriba el archivo de configuración de Spring y lo nombro spring.xml:
<? xml versión = "1.0" encoding = "utf-8"?> <frijoles xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns = "http://www.springframework.org/schema/beans" xmlns: context = "http://www.springframe mlns: tx = "http://www.springframework.org/schema/tx" xmlns: aop = "http://www.springframework.org/schema/aop" xsi: schemalocation = "http://www.springframework.org/schem http://www.springframework.org/schema/Beans/spring-Beans-4.2.2sdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4. 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.springfframework.orgschema/ http://www.springframework.org/schema/aop/spring-aop-4.2.xsd"><!-- Annotation configuration--><tx:annotation-driven transaction-manager="transactionManager" /><context:annotation-config /> <context:component-scan base-package="org.xrq" /><!-- Database connection pool, use alibaba's Druid --><bean id="dataSource" init-method="init" destroy-method="close"><property name="url" value="jdbc:mysql://localhost:3306/test" /> <property name="username" value="root" /> <property name="password" value="root" /> </bean><bean id = "sqlSessionFactory"> <Property name = "configLocation" value = "classpath: config.xml" /> <Property name = "mApperLocations" value = "classpath:*_ mapper.xml" /> <Property name = "dataSource" ref = "dataSource" /> < /bean> < name = "DataSource" ref = "dataSource"/> </le bean> </les>
Esto incluye principalmente el administrador de transacciones y el grupo de conexión de la base de datos.
Además, vemos que hay una SQLSessionFactory. Los amigos que han usado mybatis deben estar familiarizados con esta clase. Se utiliza para configurar el entorno mybatis. Hay dos atributos configslocation y mapperLocations en SQLSessionFactory. Como su nombre lo indica, representa la ubicación del archivo de configuración y la ubicación del archivo de asignación. Aquí, mientras la ruta esté configurada correctamente, Spring cargará automáticamente estos dos archivos de configuración.
Entonces, lo que desea modificar es la clase de implementación de DAO. En este momento, ya no heredas la clase MyBatisutil anterior, sino que heredas el SQLSessiondaosupport.java de MyBatis-Spring-1.x.0.jar. El código específico es el siguiente:
@RepositoryPublic Class StudentDaoImpl extiende sqlSessionDaosupport implementa StudentDao {private static string string namespace = "studentMapper.";@ResourcePublic void setSqlSessionFactory (sqlSessessionFactory sqlsessionFactory) {super.setsqlsessionfactory (sqlsession);} selectallStudents () {return getSqlSession (). SelectList (Namespace + "SelectAllStudents");} public int InsertStudent (estudiante estudiante) {return getsqlSession (). inserto (espacio de nombres + "insertStudent", estudiante);}}}}}}Aquí se usan dos anotaciones, hablemos de ellas por separado.
(1) @Repository, esta anotación es la misma que @Component, @Controller y nuestras anotaciones más comunes @Service, que pueden declarar una clase como un frijol de primavera. Sus diferencias no están en semántica específica, sino más en el posicionamiento de la anotación. Como se mencionó anteriormente, las aplicaciones de nivel empresarial se centran en el concepto de desarrollo jerárquico, por lo que estas cuatro anotaciones similares deben entenderse de la siguiente manera:
•@anotación de repositorio corresponde a la capa de persistencia, a saber, la capa DAO, que se utiliza para interactuar directamente con la base de datos. En términos generales, un método corresponde a una declaración SQL específica
•@Annotation de servicio, que corresponde a la capa de servicio, a saber, la capa de servicio, es la función de combinar declaraciones SQL únicas/múltiples. Por supuesto, si es simple, llamará directamente a un método de la capa DAO.
•@anotación del controlador, que corresponde a la capa de control, es decir, la capa de control en el modo de diseño MVC. Su función es recibir solicitudes de usuarios, llamar a diferentes servicios para obtener datos de acuerdo con las solicitudes y combinar datos de acuerdo con los requisitos y envolverlo de nuevo a la parte delantera.
•@anotación de componentes, que corresponde más al concepto de un componente. Si un frijol no sabe que pertenece a una capa, puede usar la anotación @Component para anotar.
Esto también refleja una de las ventajas de las anotaciones: ver el nombre y conocer el significado, es decir, al ver esta anotación, conoce aproximadamente la función de esta clase, es decir, su posicionamiento en todo el proyecto.
(2) @Resource, esta anotación y la anotación @autowired tienen el mismo significado, y ambos pueden inyectarse automáticamente con atributos de atributos. Dado que SQLSessionFactory es el núcleo de MyBatis, se ha declarado en Spring.xml. Por lo tanto, el bean con el ID "SQLSessionFactory" se inyecta aquí a través de la anotación @Resource. Después de eso, la SQLSession se puede obtener a través del método getsqlSession () y los datos se agregan, eliminan, modifican y verifican.
Finalmente, no es más que escribir una clase de prueba para probar:
Public Class StudentTest {public static void main (string [] args) {applicationContext ac = new classpathxmlaPlaPlicationContext ("spring.xml"); studentdao studentdao = (studentDao) ac.getBean ("studentDaoImpl"); student = new student (); student.setStudentName ("Lucy"); int j = "); int j = J = studentdao.insertstudent (estudiante); system.out.println ("j =" + j + "/n") ;System.out.println("--explay students -------"); List <deude> studentList = studentdao.selectallStudents (); para (int i = 0, longitud = studentList.size (); i <longitud; i ++) system.out.println (studentList.get (i));}} Dado que la clase StudentDaoImpl.java usa la anotación @Repository y no especifica un alias, el nombre de StudentDaoImpl.java en el contenedor de resorte es "Primera letra minúscula + letras restantes", es decir, "StudentDaoImpl".
Después de ejecutar el programa, puede ver que el nuevo estudiante fue atravesado en la consola, es decir, el estudiante fue insertado directamente en la base de datos. No hubo compromiso ni reversión en todo el proceso. Todos ellos fueron implementados por Spring. Esto es para usar la primavera para administrar las cosas en mybatis.
posdata
Este artículo revisa el uso básico de MyBatis y usa Spring para administrar cosas en MyBatis, y ofrece ejemplos de código más detallados. Los amigos necesitados pueden estudiarlo de acuerdo con el código. Según este artículo, escribiré un artículo más adelante para explicar la implementación de la gestión de cosas de múltiples datos entre tablas individuales y tablas múltiples. Este requisito también es un requisito común en empresas y aplicaciones.