Tech Blog

2024-09-05

为了在IntelliJ IDEA中配置Jakarta EE，使用Tomcat服务器和Servlet，你需要按照以下步骤操作：

确保你已经安装了IntelliJ IDEA和Tomcat服务器。
创建一个新的Java Enterprise项目。
在项目设置中配置Tomcat服务器。
创建一个简单的Servlet类。
部署应用程序到Tomcat服务器并运行。

以下是具体步骤的指导：

打开IntelliJ IDEA，点击 Create New Project。
选择 Java Enterprise 并勾选 Web Application (Servlet, JSP)。
配置项目的其他信息，然后点击 Finish。
在IDEA的右上角，点击 Run -> Edit Configurations。
点击 + 并选择 Tomcat Server -> Local。
在 Server 选项卡中，设置Tomcat服务器的路径。
在 Deployment 选项卡中，添加你的应用模块。
应用并关闭设置。

以下是一个简单的Servlet示例代码：




import javax.servlet.*;
import javax.servlet.http.*;
import java.io.IOException;
import java.io.PrintWriter;
 
public class HelloWorldServlet extends HttpServlet {
    @Override
    public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.println("<html><body><h1>Hello World</h1></body></html>");
    }
}

将Servlet配置到 web.xml 文件中，或者如果你使用的是Servlet 4.0及以上版本，可以不使用 web.xml，直接通过注解配置。




<servlet>
    <servlet-name>HelloWorldServlet</servlet-name>
    <servlet-class>HelloWorldServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>HelloWorldServlet</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>

右键点击你的Servlet类，选择 Run 'HelloWorldServlet' 或者通过 Run 菜单运行。
在浏览器中访问 http://localhost:<TomcatPort>/<ApplicationName>/hello 查看结果。

确保替换 <TomcatPort> 和 <ApplicationName> 为你的Tomcat服务器端口和应用名。

linux系统下设置oracle开机自动启动

2024-09-05

所有,数据库

在Linux系统下设置Oracle自动启动，通常涉及创建一个服务脚本并将其注册为系统服务。以下是基于systemd的系统的一个示例：

创建Oracle服务的systemd服务文件：




sudo nano /etc/systemd/system/oracle.service

在编辑器中添加以下内容：




[Unit]
Description=Oracle Database 12c
After=network.target
 
[Service]
Type=forking
User=oracle
Group=dba
 
Environment="ORACLE_HOME=/u01/app/oracle/product/12.1.0/dbhome_1"
Environment="ORACLE_SID=ORCL"
Environment="ORACLE_BASE=/u01/app/oracle"
 
ExecStart=/u01/app/oracle/product/12.1.0/dbhome_1/bin/dbstart $ORACLE_HOME
ExecStop=/u01/app/oracle/product/12.1.0/dbhome_1/bin/dbshut $ORACLE_HOME
 
[Install]
WantedBy=multi-user.target

请确保修改上述文件中的User，Group，Environment变量，如ORACLE_HOME，ORACLE_SID和ORACLE_BASE路径与您的Oracle安装相匹配。

重新加载systemd管理器配置：




sudo systemctl daemon-reload

启用Oracle服务以在启动时运行：




sudo systemctl enable oracle.service

（可选）立即启动Oracle服务：




sudo systemctl start oracle.service

确保您已经根据您的系统和Oracle安装调整了上述服务文件中的路径和参数。如果您使用的是不同的Oracle版本或安装路径，请相应地修改服务文件。

ORACLE定时器和Job：数据库界的“闹钟”与“打工仔”

2024-09-05

所有,数据库

在Oracle数据库中，可以使用DBMS\_SCHEDULER包来创建和管理定时任务（Timers），类似于Windows的定时器或Unix的Cron作业（Cron Jobs）。

以下是一个创建定时任务的例子：




BEGIN
  -- 创建一个定时任务
  DBMS_SCHEDULER.create_job (
    job_name        => 'example_job',  -- 任务名称
    job_type        => 'PLSQL_BLOCK',  -- 任务类型，这里是PL/SQL块
    job_action      => 'BEGIN NULL; END;', -- 要执行的PL/SQL块
    start_date      => SYSTIMESTAMP,    -- 任务开始时间
    repeat_interval => 'FREQ=DAILY; BYHOUR=2', -- 每天凌晨2点执行
    enabled         => TRUE,            -- 启用任务
    comments        => 'Daily job at 2 AM'); -- 任务描述
END;
/

以上代码创建了一个名为example_job的定时任务，它会每天凌晨2点执行一个空操作。

要查看现有的定时任务，可以使用以下查询：




SELECT job_name, job_type, start_date, repeat_interval, enabled, comments
FROM dba_scheduler_jobs
WHERE owner = 'YOUR_SCHEMA_NAME';

要删除一个定时任务，可以使用以下命令：




BEGIN
  DBMS_SCHEDULER.drop_job(job_name => 'example_job', force => TRUE);
END;
/

这个例子展示了如何使用DBMS\_SCHEDULER包来管理Oracle数据库中的定时任务。这是数据库级别的“闹钟”和“打工仔”，非常适合执行定期任务，如数据库备份、清理作业等。

Spring Boot项目访问不了resources中的jsp页面

2024-09-05

解释：

Spring Boot项目访问不了resources目录下的JSP页面通常是因为以下几个原因：

Spring Boot默认不支持JSP，需要额外配置。
JSP文件没有放在正确的目录下（应该放在src/main/webapp/WEB-INF目录下）。
内嵌的Tomcat服务器可能没有配置正确来加载JSP文件。
项目打包方式不正确，如果使用了JSP，打包方式应该是war，而不是Spring Boot默认的jar。

解决方法：

添加JSP相关依赖到pom.xml：




<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
</dependency>

确保JSP文件放置在src/main/webapp/WEB-INF目录下。
在application.properties或application.yml中配置JSP文件的基目录和后缀：
```
spring.mvc.view.prefix=/WEB-INF/
spring.mvc.view.suffix=.jsp
```

如果打算打包成war文件部署，修改pom.xml中的<packaging>标签为war，并添加一个用于排除内置Tomcat的依赖：




<packaging>war</packaging>
...
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>

确保控制器中的映射路径正确，并且符合配置的前缀和后缀。

如果以上步骤正确完成，Spring Boot项目应该能够正确访问resources目录下的JSP页面。

Spring Boot中多线程的使用

2024-09-05

在Spring Boot中使用多线程，可以通过以下两种常见方式实现：

使用@Async注解：

在Spring Boot中，可以通过@Async注解来创建异步方法，Spring会将这些方法的执行放在后台线程中。

示例代码：




@Service
public class AsyncService {
 
    @Async
    public void executeAsyncTask() {
        System.out.println("执行异步任务：" + Thread.currentThread().getName());
    }
}
 
@RestController
public class AsyncController {
 
    @Autowired
    private AsyncService asyncService;
 
    @GetMapping("/async")
    public String asyncCall() {
        asyncService.executeAsyncTask();
        return "Async task submitted";
    }
}

使用ThreadPoolTaskExecutor：

通过定义一个ThreadPoolTaskExecutor的Bean，可以创建一个线程池，然后在需要多线程执行任务的地方使用这个线程池。

示例代码：




@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {
 
    @Override
    @Bean
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(25);
        executor.initialize();
        return executor;
    }
}
 
@Service
public class TaskExecutorService {
 
    @Autowired
    private Executor executor;
 
    public void executeTask() {
        executor.execute(() -> {
            System.out.println("执行线程池任务：" + Thread.currentThread().getName());
        });
    }
}

在实际使用时，根据需要选择合适的方式来创建和管理多线程。

2024-09-05

Spring Cloud 是一系列框架的有序集合，主要用于简化分布式系统的开发。在这个问题中，你提到了几个核心组件：Feign、Gateway、Nacos 和配置中心。

Feign：Feign 是一个声明式的 Web 服务客户端，用来简化 HTTP 远程调用。你可以用 Feign 创建一个接口并用注解的方式来配置远程调用的信息，比如 URL、HTTP 方法和参数等。




@FeignClient(name = "serviceName", url = "http://localhost:8080")
public interface MyFeignClient {
    @GetMapping("/endpoint")
    String getData();
}

Gateway：Spring Cloud Gateway 是 Spring Cloud 的一个全新项目，用于提供一个简单有效的路由 API 的方式。




@SpringBootApplication
public class GatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(GatewayApplication.class, args);
    }
 
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
                .route("path_route", r -> r.path("/get")
                        .uri("http://localhost:8080"))
                .build();
    }
}

Nacos：Nacos 是一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。

配置管理：使用 Nacos 配置中心，可以在微服务运行时动态更新配置信息。




@Configuration
public class NacosConfig {
    @NacosValue(value = "${useLocalCache:false}", autoRefreshed = true)
    private boolean useLocalCache;
 
    public boolean isUseLocalCache() {
        return useLocalCache;
    }
}

服务注册与发现：Nacos 支持服务的注册与发现，使得服务之间的调用更为简单。




@SpringBootApplication
@EnableDiscoveryClient
public class ServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceApplication.class, args);
    }
}

综上所述，Spring Cloud 结合这些组件可以帮助开发者快速搭建一套微服务架构。Feign 用于服务间的 REST 调用，Gateway 用于 API 网关，Nacos 则用于服务注册与发现，以及配置管理。

【Java EE】SpringBoot的创建与简单使用

2024-09-05




import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
@SpringBootApplication // 标注这是一个Spring Boot应用
public class MySpringBootApplication {
 
    public static void main(String[] args) {
        // 启动Spring Boot应用
        SpringApplication.run(MySpringBootApplication.class, args);
    }
}

这段代码创建了一个简单的Spring Boot应用程序，并在main方法中启动了它。通过@SpringBootApplication注解，Spring Boot会自动配置Spring容器，使得开发者可以快速启动并运行一个生产级别的Spring应用程序。

东方通TongWeb结合Spring-Boot使用

2024-09-05

在Spring Boot中使用东方通TongWeb作为Servlet容器，通常需要在pom.xml中添加TongWeb的依赖，并配置application.properties或application.yml文件。以下是一个基本的配置示例：

在pom.xml中添加TongWeb的依赖（请确保依赖的版本与您使用的TongWeb版本兼容）：




<dependencies>
    <!-- 其他依赖 -->
 
    <!-- 添加TongWeb的依赖 -->
    <dependency>
        <groupId>com.tongweb.boot</groupId>
        <artifactId>tongweb-boot</artifactId>
        <version>您的TongWeb版本</version>
    </dependency>
</dependencies>

在application.properties或application.yml中配置TongWeb的相关属性：




# application.properties
server.port=8080 # 应用端口
server.servlet.context-path=/app # 应用上下文路径
 
# 如果使用的是TongWeb的特定配置，则可能需要配置如下：
tongweb.home=TONGWEB_INSTALLATION_PATH # TongWeb安装路径
tongweb.httpPort=8080 # TongWeb的HTTP端口
tongweb.httpsPort=8443 # TongWeb的HTTPS端口
tongweb.adminPort=7001 # TongWeb的管理端口

创建一个Spring Boot启动类：




import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
@SpringBootApplication
public class TongWebApplication {
    public static void main(String[] args) {
        SpringApplication.run(TongWebApplication.class, args);
    }
}

创建一个Controller进行测试：




import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class HelloController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello from TongWeb";
    }
}

确保您已正确安装并配置了TongWeb，并且在使用之前已经阅读了TongWeb与Spring Boot集成的官方文档。

以上代码仅为示例，实际使用时需要根据您的项目需求和TongWeb的版本进行相应的调整。

2024-09-05

在Spring Cloud Kubernetes中，可以使用k8s原生的Service资源实现服务注册和发现。Spring Cloud Kubernetes提供了自动化配置，使得开发者可以像在非Kubernetes环境中使用Spring Cloud那样，无需手动管理服务实例。

以下是一个简单的例子，展示如何在Spring Boot应用中使用k8s的Service：

在pom.xml中添加Spring Cloud Kubernetes依赖：




<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-kubernetes</artifactId>
    </dependency>
    <!-- 其他依赖 -->
</dependencies>

在application.yml或application.properties中配置Spring Cloud Kubernetes：




spring:
  cloud:
    kubernetes:
      discovery:
        service-name: my-service

在代码中使用服务发现：




@RestController
public class MyController {
 
    @Autowired
    private DiscoveryClient discoveryClient;
 
    @GetMapping("/services")
    public List<String> serviceList() {
        return discoveryClient.getServices();
    }
 
    // 其他控制器方法
}

在这个例子中，my-service是k8s中定义的Service名称。Spring Cloud Kubernetes会自动发现该Service下的所有Pod实例，并将它们作为服务实例暴露给Spring应用。这样，你就可以使用DiscoveryClient来获取服务列表，并调用其他服务提供的接口。

ElementUI Form表单里使用 v-for循环创建表单元素校验

2024-09-05

所有,elementui

在ElementUI中使用v-for循环创建表单元素并进行验证，你需要为每个循环的表单元素设置一个唯一的prop属性，并使用v-model绑定数据。同时，你可以使用:rules属性来定义验证规则。

以下是一个简单的例子：




<template>
  <el-form ref="form" :model="form" label-width="80px">
    <el-form-item
      v-for="(item, index) in form.items"
      :key="index"
      :prop="'items.' + index + '.value'"
      :label="'Item ' + (index + 1)"
      :rules="[
        { required: true, message: '请输入内容', trigger: 'blur' },
        { min: 3, max: 5, message: '长度在 3 到 5 个字符', trigger: 'blur' }
      ]"
    >
      <el-input v-model="item.value"></el-input>
    </el-form-item>
    <el-button type="primary" @click="submitForm">提交</el-button>
  </el-form>
</template>
 
<script>
export default {
  data() {
    return {
      form: {
        items: [
          { value: '' },
          { value: '' },
          // 可以根据需要添加更多的items
        ]
      }
    };
  },
  methods: {
    submitForm() {
      this.$refs.form.validate((valid) => {
        if (valid) {
          alert('验证通过');
        } else {
          console.log('验证失败');
          return false;
        }
      });
    }
  }
};
</script>

在这个例子中，我们定义了一个包含多个items的form对象，每个item都有一个value属性用于绑定输入字段。在el-form-item中，我们使用:prop动态设置为items.[index].value，这样每个表单项都有一个独特的验证规则。:rules属性定义了字段需要输入的长度和必填性。当用户点击提交按钮时，会触发submitForm方法，该方法会调用表单的validate方法来进行验证。如果所有的表单项都通过验证，则会弹出一个提示框显示“验证通过”，否则在控制台输出“验证失败”。