Mybatis-Plus-[explicación completa fácil de entender]

Mybatis Plus

Introducción

MyBatis-Plus (se abre en una ventana nueva) (MP para abreviar) es una herramienta de mejora para MyBatis (se abre en una ventana nueva).Sobre la base de MyBatis, solo se realizan mejoras sin cambios, y nació para simplificar el desarrollo y mejorar la eficiencia.
Consulte el sitio web oficial para obtener más detalles: https://baomidou.com/pages/24112f/#%E7%89%B9%E6%80%A7

Inicio rápido

1. construir mesa

DROP TABLE IF EXISTS user;

CREATE TABLE user
(
    id BIGINT(20) NOT NULL COMMENT '主键ID',
    name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
    age INT(11) NULL DEFAULT NULL COMMENT '年龄',
    email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',
    PRIMARY KEY (id)
);

DELETE FROM user;

INSERT INTO user (id, name, age, email) VALUES
(1, 'Jone', 18, '[email protected]'),
(2, 'Jack', 20, '[email protected]'),
(3, 'Tom', 28, '[email protected]'),
(4, 'Sandy', 21, '[email protected]'),
(5, 'Billie', 24, '[email protected]');

2. Crear un proyecto de Spring Boot vacío
3. Agregar dependencias MySQL, lombok, mybatis_plus

<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<version>8.0.28</version>
</dependency>
<dependency>
	<groupId>org.projectlombok</groupId>
	<artifactId>lombok</artifactId>
	<version>1.18.22</version>
</dependency>
<dependency>
	<groupId>com.baomidou</groupId>
	<artifactId>mybatis-plus-boot-starter</artifactId>
	<version>3.5.1</version>
</dependency>

4. Escriba un archivo de configuración y conéctese a la base de datos

spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?useSSL=true&useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

5. Manera tradicional pojo-dao (conectar mybatis, configurar archivo mapper.xml)-controlador de servicio
5. Después de usar mybatis-plus ( heredar la interfaz BaseMapper, omitiendo el archivo mapper.xml )

• caca

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    
    
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

• interfaz del mapeador

//在对应的mapper上面继承基本接口就可以 BaseMapper
@Repository//代表持久层
public interface UserMapper extends BaseMapper<User> {
    //所有的CRUD操作都已经编写完成了
    //你不需要像以前一样配置一大堆文件了
}

• Tenga en cuenta que necesitamos escanear todas las interfaces en nuestro paquete mapeador en la clase de inicio principal@MapperScan("com.kuang.mapper")

//扫描我们的mapper文件夹
@MapperScan("com.kuang.mapper")
@SpringBootApplication
public class MybatisPlusApplication {
    
    

    public static void main(String[] args) {
    
    
        SpringApplication.run(MybatisPlusApplication.class, args);
    }

}

• prueba de clase de prueba

@SpringBootTest
class MybatisPlusApplicationTests {
    
    
    //继承了BaseMapper，所有方法都来自父类，我们也可以编写自己的拓展方法
    @Autowired
    private UserMapper userMapper;

    @Test
    void contextLoads() {
    
    
        //这里的参数是一个Wrapper,条件构造器，这里我们先不用，将其设为null
        //查询全部用户
        List<User> userList = userMapper.selectList(null);
        userList.forEach(System.out::println);
    }
}

pensar en el problema

1. ¿Quién escribió SQL para nosotros? MyBatis-Plus
2. ¿De dónde salió el método? MyBatis-Plus

registro de configuración

Todo nuestro sql ahora es invisible, queremos saber cómo se ejecuta, ¡así que tenemos que ver el registro!

# 配置日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

Después de configurar el registro, debe prestar atención a este SQL generado automáticamente en los siguientes estudios, ¡y le gustará Mybatis-Plus!

Extensión CRUD

operación de inserción

insertar insertar

    @Test//测试插入
    public void textInsert() {
    
    
        User user = new User();
        user.setName("lala啦");
        user.setAge(3);
        user.setEmail("[email protected]");
        int result = userMapper.insert(user);//帮我们自动生成id
        System.out.println(result);//受影响的行数
        System.out.println(user);//发现，id会自动回填
    }

El valor predeterminado de la identificación insertada en la base de datos es: identificación única global

estrategia de generacion de clave primaria

ASSIGN_ID ID único global predeterminado

Generación de identificación única del sistema distribuido: https://www.cnblogs.com/haoxinyue/p/5208136.html
Algoritmo Snowflake:
Snowflake es el algoritmo de generación de identificación distribuida de código abierto de Twitter y el resultado es una identificación larga. La idea central es: usar 41 bits como el número de milisegundos, 10 bits como la ID de la máquina (5 bits son el centro de datos, 5 bits para la ID de la máquina) y 12 bits como el número de serie en milisegundos (lo que significa que cada nodo puede generar 4096 ID), hay un bit de signo al final, que siempre es 0. Garantizado para ser casi único en el mundo!

incremento automático de clave principal

Necesitamos configurar el incremento automático de la clave principal:

1. campo de clase de entidad@TableId(type = IdType.AUTO)
2. ¡Los campos de la base de datos deben ser autocrecientes!
   
3. Simplemente pruebe la inserción nuevamente, ¡y el incremento es 1!

Explicación del código fuente del resto del IdType

public enum IdType {
    
    
    AUTO(0),//数据库id自增
    NONE(1),//未设置主键
    INPUT(2),//手动输入,就需要自己配置id了
    ASSIGN_ID(3),//默认的全局唯一id 
    ASSIGN_UUID(4);//全局唯一id

operación de actualización

 @Test
    //测试更新
    public void testUpdate(){
    
    
        User user = new User();
        //通过条件自动拼接动态sql
        user.setId(6L);
        user.setName("lala嘿嘿");
        user.setAge(3);
        user.setEmail("[email protected]");
        //注意：userById 但是参数是一个对象
        int i = userMapper.updateById(user);
        System.out.println(i);
    }

¡Todo el sql se configura automáticamente de forma dinámica para usted!

autocompletar

¡Tiempo de creación, tiempo de modificación! Todas estas operaciones se realizan automáticamente, ¡no queremos actualizar manualmente!
Manual de desarrollo de Alibaba: Todas las tablas de la base de datos: gmt_create, gmt_modified ¡Casi todas las tablas deben configurarse! ¡Y necesita ser automatizado!

Método 1: nivel de base de datos (no se le permite modificar la base de datos durante el trabajo)

1. Agregue nuevos campos create_time, update_time a la tabla
   
2. Para probar el método de inserción nuevamente, primero debemos sincronizar la clase de entidad.

private Date createTime;
private Date updateTime;

3. Actualizar de nuevo para ver los resultados
   
   aparece el problema: Además de insertar registros, el resto del tiempo de creación y el tiempo de actualización son nulos
   Resolver el problema: Al crear un campo, debe establecerse que el campo no puede estar vacío
   

Método 2: nivel de código

1. Elimine los valores predeterminados de los dos campos create_time y update_time en la base de datos, operación de actualización update_time
   
2. Las anotaciones deben agregarse a los atributos de campo de clase de entidad

    //字段添加填充内容
    //插入的时候填充字段
    @TableField(fill = FieldFill.INSERT)
    private Date createTime;
    //插入和更新的时候填充字段
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;

3. ¡Simplemente escriba un procesador para manejar esta anotación!

@Slf4j//对日志依赖的引用
@Component//一定不要忘记把处理器增加到IOC容器中！
public class MyMetaObjectHandler implements MetaObjectHandler {
    
    

    //插入时的填充策略
    @Override
    public void insertFill(MetaObject metaObject) {
    
    
        log.info("start insert fill......");
        this.setFieldValByName("createTime",new Date(),metaObject);
        //MetaObject[反射对象类]是Mybatis的工具类，通过MetaObject获取和设置对象的属性值。
        this.setFieldValByName("updateTime",new Date(),metaObject);
    }

    //更新时的填充策略
    @Override
    public void updateFill(MetaObject metaObject) {
    
    
        log.info("start update fill.....");
        this.setFieldValByName("updateTime",new Date(),metaObject);
    }
}

4. inserción de prueba
5. Solo prueba la actualización y observa la hora.

• resumen: Pero una cosa, descubrí que otros registros no crearon los dos campos de create_time y update_time por defecto. Solo se llenarán los campos que se han insertado o actualizado.

candado optimista

Cerradura optimista: como su nombre indica, es muy optimista, siempre piensa que no habrá problemas, haga lo que haga, ¡no se bloqueará! Si hay un problema, se bloqueará y la actualización fallará.Bloqueo
pesimista: como su nombre lo indica, es muy pesimista.Siempre piensa que habrá un problema y lo bloqueará sin importar lo que haga. ! volver a operar

¡Aquí explicamos principalmente el mecanismo de bloqueo optimista!
Implementación de bloqueo optimista

• Al buscar registros, obtener la versión actual
• Al actualizar, traer esta versión
• Al realizar una actualización, configure version = newVersion donde version = oldVersion
• Si la versión es incorrecta, la actualización fallará
  [en resumen, es una actualización continua, cuando se encuentra que la versión es incorrecta, es decir, cuando se encuentra un problema, se bloqueará y la actualización fallará]

//乐观锁：1.先查询，获得版本号 version = 1
--A
update user set name = "kuangshen" ,version = version + 1
where id = 2 and version = 1
--B 线程抢先完成，这个时候 version = 2,会导致 A 修改失败！
update user set name = "kuangshen" ,version = version + 1
where id = 2 and version = 1

Pruebe el complemento de bloqueo optimista de Mybatis-Plus

1. ¡Agregue un campo de versión a la base de datos!
   
2. Nuestra clase de entidad necesita agregar los campos correspondientes

	@Version//乐观锁Version注解
	private Integer version;

3. registrar componente

//扫描我们的mapper文件夹
@MapperScan("com.kuang.mapper")
@EnableTransactionManagement//自动管理事务开启，默认也是开启的
@Configuration//这是一个配置类
public class MybatisPlusConfig {
    
    
    //注册乐观锁插件
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
    
    
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return interceptor;
    }
}

4. tener una prueba

    //测试乐观锁成功
    @Test
    public void testOptimisticLocker(){
    
    
        //1.查询
        User user = userMapper.selectById(1L);
        //2.修改，它很乐观它觉得这个用户没有问题，，进行修改
        user.setName("呀嘿");
        user.setEmail("[email protected]");
        user.setAge(2);
        //3.执行更新操作
        userMapper.updateById(user);
    }

    //测试乐观锁失败
    @Test
    public void testOptimisticLocker2(){
    
    

        //线程一
        User user = userMapper.selectById(1L);
        user.setName("yiyi嘿11");
        user.setEmail("[email protected]");

        //模拟另外一个线程执行了插队操作
        User user2 = userMapper.selectById(1L);
        user2.setName("yi嘿哈22");
        user2.setEmail("[email protected]");

        userMapper.updateById(user2);
		//自旋锁来多次尝试提交！
        userMapper.updateById(user);//如果没有乐观锁就会覆盖插队线程的值！
    }

Spinlock (extendido)

"Girar" significa que sigues dando vueltas aquí hasta que se logra el objetivo. A diferencia de los candados ordinarios, si no se puede adquirir el candado, entrará en bloqueo

operación de consulta

    //测试批量查询！
    @Test
    public void testSelectByBatchId(){
    
    
        List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
        users.forEach(System.out::println);
    }

    //按条件查询之一使用 map 操作
    @Test
    public void testSelectByBatchIds() {
    
    
        HashMap<String, Object> map = new HashMap<>();
        //自定义要查询
        map.put("name","Jack");
        List<User> users = userMapper.selectByMap(map);
        users.forEach(System.out::println);
    }

Consulta de paginación

¡La paginación se usa mucho en el sitio web!

1. El límite original para la paginación.
2. Complemento de terceros pageHelper
3. De hecho, MP también tiene complementos de paginación incorporados.

¡cómo utilizar!

1. Simplemente configure el componente interceptor

    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
    
    
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();    
        //分页插件
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.H2));
        //乐观锁插件
        interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return interceptor;
    }

2. ¡Simplemente use el objeto Página directamente!

    //测试分页查询
    @Test
    public void testPage(){
    
    
        //参数一：当前页
        //参数二：页面大小
        //使用了分页插件后，所有的分页操作也变得简单了
        IPage page = new Page<>(2, 5);
        userMapper.selectPage(page,null);
        page.getRecords().forEach(System.out::println);
        System.out.println(page.getTotal());
    }

borrar operación

Operación básica de eliminación

//测试删除
    //通过id
    @Test
    public void testDeleteById(){
    
    
        userMapper.deleteById(1518117539816615937L);
    }

    //通过id批量删除
    @Test
    public void testDeleteBatchIds(){
    
    
        userMapper.deleteBatchIds(Arrays.asList(1518117539816615938L,8L));
    }

    //通过map删除
    @Test
    public void testDeleteMap(){
    
    
        HashMap<String, Object> map = new HashMap<>();
        map.put("name","yi嘿哈22");
        userMapper.deleteByMap(map);
    }

Nos encontraremos con algunos problemas en el trabajo: ¡borrado lógico!

Lápida sepulcral

Eliminación física: eliminada directamente de la base de datos
Eliminación lógica: no eliminada de la base de datos, ¡pero invalidada por una variable! borrar = 0>>borrar=1

¡Los administradores pueden ver los registros eliminados! ¡Evite la pérdida de datos, similar a la papelera de reciclaje!
tener una prueba:

1. Agregar un campo de eliminación a la tabla de datos
   
2. Agregar atributo a la clase de entidad

    @TableLogic//逻辑删除
    private Integer deleted;

3. ¡configuración!
   Ejemplo: aplicación.yml

mybatis-plus:
  global-config:
    db-config:
      logic-delete-field: flag  # 全局逻辑删除的实体字段名(since 3.3.0,配置后可以忽略不进行@TableLogic注解)
      logic-delete-value: 1 # 逻辑已删除值(默认为 1)
      logic-not-delete-value: 0 # 逻辑未删除值(默认为 0)

4. Pruebe la eliminación.
   La operación de actualización se realiza en lugar de la operación de eliminación.
   
   Los datos no se eliminan, pero el valor del campo eliminado se marca como 1.
   
   Al consultar, eliminado se empalmará automáticamente, y la condición de eliminado = 0 será ser agregado.
   

Resumen CRUD

¡Debemos ser competentes en todas las operaciones CRUD anteriores y operaciones extremadamente extendidas! ¡Mejorará en gran medida la eficiencia de su trabajo y proyectos de escritura!
Nota: Las operaciones anteriores son solo de referencia. Según las diferentes versiones y actualizaciones más rápidas, el contenido se basa principalmente en el sitio web oficial de Mybatis-Plus, y su contenido también es fácil de leer.

Complemento de análisis de rendimiento

Función: interceptor de análisis de rendimiento, utilizado para generar cada instrucción SQL y su tiempo de ejecución.
Si excede este tiempo, dejará de ejecutarse.
Dado que esta versión de MP es relativamente nueva, el sitio web oficial no tiene un complemento de análisis de rendimiento de MP, por lo que aquí se utiliza un complemento p6spy de terceros

1.导入pom相关依赖
<!--mybatis-plus-->
<dependency>
	<groupId>com.baomidou</groupId>
	<artifactId>mybatis-plus-boot-starter</artifactId>
	<version>3.5.1</version>
</dependency>
<!--执行 SQL 分析打印插件-->
<dependency>
	<groupId>p6spy</groupId>
	<artifactId>p6spy</artifactId>
	<version>3.8.1</version>
</dependency>
<!--mybatis-plus代码生成器-->
<dependency>
	<groupId>com.baomidou</groupId>
	<artifactId>mybatis-plus-generator</artifactId>
	<version>3.5.1</version>
</dependency>
 
2.修改 application.yml
### 默认配置如下
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mybatis_plus?useUnicode=true&characterEncoding=utf8&useSSL=false&useLegacyDatetimeCode=false&serverTimezone=GMT%2b8&tinyInt1isBit=true
    username: root
    password: 123456
### 修改配置如下
spring:
  datasource:
  driver-class-name: com.p6spy.engine.spy.P6SpyDriver
  url: jdbc:p6spy:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf8&useSSL=false&useLegacyDatetimeCode=false&serverTimezone=GMT%2b8&tinyInt1isBit=true
  
3.在项目的resources下添加"spy.properties" p6spy的位置文件
modulelist=com.baomidou.mybatisplus.extension.p6spy.MybatisPlusLogFactory,com.p6spy.engine.outage.P6OutageFactory
# 自定义日志打印
logMessageFormat=com.baomidou.mybatisplus.extension.p6spy.P6SpyLogger
#日志输出到控制台
appender=com.baomidou.mybatisplus.extension.p6spy.StdoutLogger
# 使用日志系统记录 sql
#appender=com.p6spy.engine.spy.appender.Slf4JLogger
# 设置 p6spy driver 代理
deregisterdrivers=true
# 取消JDBC URL前缀
useprefix=true
# 配置记录 Log 例外,可去掉的结果集有error,info,batch,debug,statement,commit,rollback,result,resultset.
excludecategories=info,debug,result,commit,resultset
# 日期格式
dateformat=yyyy-MM-dd HH:mm:ss
# 实际驱动可多个
#driverlist=org.h2.Driver
# 是否开启慢SQL记录
outagedetection=true
# 慢SQL记录标准 2 秒
outagedetectioninterval=2
 
4.执行查询接口
控制台会显示如下代码
 Consume Time：20 ms 2020-06-30 09:26:25
 Execute SQL：SELECT ID, NAME, AGE, SEX, date_format( INPUT_DATE, '%Y-%c-%d %h:%i:%s' ) inputDate FROM student where 1=1 LIMIT 10 

¡El uso de complementos de análisis de rendimiento puede ayudarnos a mejorar la eficiencia!

constructor condicional

Es muy importante.
Podemos usarlo para reemplazar 1. Pruebe 1 escribiendo un SQL complejo
. Recuerde verificar el SQL de salida para el análisis.

@Test
void contextLoads(){
    
    
    //查询name不为空，邮箱不为空的用户，年龄大于等于24
    QueryWrapper<User> wrapper = new QueryWrapper<>();//和mapper很像，但是wrapper是一个对象，不用put,而是去用方法
    wrapper
            .isNotNull("name")
            .isNotNull("email")
            .ge("age",24);
    userMapper.selectList(wrapper).forEach(System.out::println);
}

2. Prueba 2, recuerde ver el SQL de salida para su análisis

@Test
void contextLoads2(){
    
    
     //查询名字为Tom的
     QueryWrapper<User> wrapper = new QueryWrapper<>();
     wrapper.eq("name","Tom");
     User user = userMapper.selectOne(wrapper);//查询一个数据，出现多个结果使用List或者Map
     System.out.println(user);
 }

3. Prueba 3, recuerde ver el SQL de salida para su análisis

@Test
void contextLoads3(){
    
    
    //查询年龄在20-30之间的用户
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.between("age",20,30);//区间,不包括20和30
    Long count = userMapper.selectCount(wrapper);//查询结果数量
    System.out.println(count);
}

4. Prueba 4, recuerde ver el SQL de salida para su análisis

//模糊查询
@Test
void contextLoads4(){
    
    
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    //t在% 左和右
    wrapper
            .notLike("name","a")//名字中没有a和A
            .likeRight("email","t");//邮箱以字母t开头
    userMapper.selectMaps(wrapper).forEach(System.out::println);
}

5. Prueba cinco, recuerda ver el SQL de salida para su análisis

@Test
void contextLoads5(){
    
    
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    // 在子查询中查出来
    wrapper.inSql("name","select name from user where id < 5");
    List<Object> objects = userMapper.selectObjs(wrapper);
    objects.forEach(System.out::println);
}

6. Prueba seis

@Test
void contextLoads6(){
    
    
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    //通过id进行降序排序 ASC升序
    wrapper.orderByDesc("id");
    List<User> users = userMapper.selectList(wrapper);
    users.forEach(System.out::println);
}

generador de código automático

¡dao, pojo, servicio, controlador se escriben automáticamente!
1. Escriba primero las dependencias

<!--代码中设置freemarker了模板，故在此加依赖，默认模板为velocity模板-->
<dependency>
    <groupId>org.freemarker</groupId>
    <artifactId>freemarker</artifactId>
    <version>2.3.31</version>
</dependency>
<!--mybatis-plus代码生成器-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-generator</artifactId>
    <version>3.5.1</version>
</dependency>

2. Ejecuta el código

package com.kuang;

import com.baomidou.mybatisplus.generator.FastAutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.OutputFile;
import com.baomidou.mybatisplus.generator.config.converts.MySqlTypeConvert;
import com.baomidou.mybatisplus.generator.config.querys.MySqlQuery;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;
import com.baomidou.mybatisplus.generator.keywords.MySqlKeyWordsHandler;

import java.util.Collections;

public class lqc {
    
    
    public static void main(String[] args) {
    
    
        String projectPath = System.getProperty("user.dir");//user.dir	用户当前工作目录
        FastAutoGenerator.create("jdbc:p6spy:mysql://localhost:3306/mybatis_plus?useSSL=true&useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8", "root", "123456")
                //1.全局配置
                .globalConfig(builder -> {
    
    
                    builder.author("lqc") // 设置作者
                            .enableSwagger() // 开启 swagger 模式
                            .fileOverride() // 覆盖已生成文件
                            .outputDir(projectPath+"/src/main/java");// 指定输出目录

                })
                //3.包的配置
                .packageConfig(builder -> {
    
    
                    builder.parent("com.kuang") // 设置父包名
                            .moduleName("blog") // 设置父包模块名
                            .pathInfo(Collections.singletonMap(OutputFile.mapperXml, projectPath+"/src/main/java")); // 设置mapperXml生成路径
                })
                //4.策略配置
                .strategyConfig(builder -> {
    
    
                    builder.addInclude("student") // 设置需要生成的表名
                            .addTablePrefix("t_", "c_"); // 设置过滤表前缀
                })
                .templateEngine(new FreemarkerTemplateEngine()) // 使用Freemarker引擎模板，默认的是Velocity引擎模板
                .execute();
        //2.数据库的配置
        new DataSourceConfig.
                Builder("jdbc:p6spy:mysql://localhost:3306/mybatis_plus?useSSL=true&useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8","root","123456")
                .dbQuery(new MySqlQuery())
                .schema("mybatis_plus")
                .typeConvert(new MySqlTypeConvert())
                .keyWordsHandler(new MySqlKeyWordsHandler())
                .build();
    }
}

3. El archivo se

genera automáticamente

–La mayor parte del contenido proviene de Kuangshenshuo JAVA