分类后端技术下的文章

2024-09-06

Apache Tomcat 是一个开源的Java Web应用服务器，提供了对Java Servlet和JavaServer Pages (JSP)的支持。以下是一个简单的例子，展示如何在Tomcat中部署一个简单的Servlet应用。

创建一个简单的Servlet类：




import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
 
public class HelloWorldServlet extends HttpServlet {
    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为WAR文件：

将上面的Servlet类编译后，打包成WAR文件。假设你的Servlet包名为com.example.HelloWorldServlet，可以使用如下命令打包：




jar -cvf hello.war com/example/HelloWorldServlet.class

部署WAR到Tomcat：

将生成的hello.war文件复制到Tomcat的webapps目录下。

启动Tomcat：

在Tomcat安装目录下执行bin/startup.sh (在Windows中是bin/startup.bat) 来启动Tomcat。

访问Servlet：

启动Tomcat后，打开浏览器，访问http://localhost:8080/hello，你应该能看到"Hello World"的消息。

这个例子展示了如何创建一个简单的Servlet，如何将其打包成WAR文件，以及如何在Tomcat服务器上部署和运行它。

System

2024-09-06

所有,数据库

报错解释：

DPI-1047错误表示Oracle客户端无法定位到64位的Oracle客户端库。这通常发生在尝试连接到Oracle数据库时，但系统上没有安装适当的64位Oracle客户端软件。

解决方法：

确认是否已安装64位Oracle客户端。如果没有，需要下载并安装适当版本的Oracle客户端软件。
如果已安装客户端，确保环境变量正确设置。需要设置PATH环境变量，使其包含Oracle客户端库的路径。
如果是通过Oracle的Instant Client连接，确保下载了适合操作系统的64位版本，并且将其解压后的目录路径添加到PATH环境变量中。
重启应用程序或命令行界面，以便更改生效。
如果是在使用某个特定的应用程序时遇到此错误，请检查该应用程序的配置设置，确保它们指向正确的Oracle客户端库路径。

请根据您的操作系统和需求下载相应的Oracle Instant Client。下载地址可以在Oracle官方网站上找到。

- 阅读更多 -

oracle数据库导入导出

System

2024-09-06

所有,数据库

Oracle数据库的导入导出通常使用expdp和impdp工具，这些是Data Pump的命令行工具，它们用于执行高速的数据和元数据的迁移。

导出（Export）数据：




expdp username/password@db_link DIRECTORY=directory_name DUMPFILE=dump_file_name.dmp SCHEMAS=schema_name

导入（Import）数据：




impdp username/password@db_link DIRECTORY=directory_name DUMPFILE=dump_file_name.dmp SCHEMAS=schema_name REMAP_SCHEMA=old_schema:new_schema TABLE_EXISTS_ACTION=replace

在这些命令中：

username/password：替换为你的数据库用户名和密码。
db_link：替换为你的数据库连接字符串。
directory_name：需要是数据库目录对象，指向一个实际的文件系统目录。
dump_file_name.dmp：导出文件的名称。
schema_name：要导入或导出的模式名称。
old_schema:new_schema：当需要重新映射模式名称时使用。
TABLE_EXISTS_ACTION：设置为replace可以覆盖现有的表，其他选项包括append、skip、truncate等。

确保在执行导入导出操作前，数据库用户具有足够的权限，并且指定的目录对象存在且数据库用户有足够的权限访问。

System

2024-09-06

所有,java

Spring Boot 打成 WAR 包通常需要以下步骤：

在 pom.xml 中修改打包方式为 war：




<packaging>war</packaging>

添加 spring-boot-starter-web 依赖，并排除嵌入式容器（Tomcat、Jetty 等）：




<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>

添加 provided 作用域的 servlet-api 和 jsp-api 依赖：




<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>javax.servlet.jsp-api</artifactId>
    <version>2.3.1</version>
    <scope>provided</scope>
</dependency>

创建 SpringBootServletInitializer 的子类并覆盖 configure 方法：




import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.context.annotation.Configuration;
 
@Configuration
public class ServletInitializer extends SpringBootServletInitializer {
 
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(YourApplication.class);
    }
}

打包时使用 mvn clean package。

Vue 打成 WAR 包并部署到 Tomcat 或 WebSphere 中，你需要做以下操作：

在 Vue 项目中执行 npm run build 来生成 dist/ 文件夹。
将生成的 dist/ 文件夹复制到 Spring Boot 项目的 src/main/webapp 目录（如果不存在则创建）。
在 src/main/webapp 下创建 index.html 文件，确保有正确的 publicPath 和 assetsDir。
修改 application.properties 或 application.yml 文件，确保静态资源的映射正确：




spring.resources.static-locations=classpath:/META-INF/resources/,classpath:/resources/,classpath:/static/,classpath:/public/

打包 Spring Boot 项目，上述步骤已经包含了如何打包成 WAR。
将生成的 WAR 包部署到 Tomcat 或 WebSphere。

在部署时，确保 Tomcat 或 WebSphere 的 Servlet 容器没有覆盖你的 Spring Boot 应用。通常，Spring Boot 的应用会在 web.xml 中配置或者通过注解的方式启动。如果你使用的是 Spring Boot 2.x 版本，默认使用内嵌的 Tomcat，你需要将其关闭并配置外部的 Servlet

- 阅读更多 -

Spring——事务注解@Transactional【建议收藏】

System

2024-09-06

所有,java

@Transactional 是 Spring 框架中用于声明式事务管理的注解。它可以被应用于接口定义、接口方法、类定义或类的 public 方法上。

使用方法：

在 Spring 配置文件中添加 <tx:annotation-driven /> 或者使用 @EnableTransactionManagement 注解来启用注解式事务管理。
在需要进行事务管理的方法上使用 @Transactional 注解。

注解属性：

value 或 transactionManager：指定事务管理器。
propagation：指定事务传播行为。
isolation：指定事务的隔离级别。
readOnly：指定事务是否只读。
timeout：指定事务的超时时间。
rollbackFor：指定一个异常类数组，遇到这些异常时事务会回滚。
noRollbackFor：指定一个异常类数组，遇到这些异常时事务不会回滚。

示例代码：




import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
@Service
public class MyService {
 
    @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.READ_COMMITTED, timeout = 10, readOnly = false)
    public void someTransactionalMethod() {
        // 方法逻辑
    }
}

在这个例子中，someTransactionalMethod 方法被 @Transactional 注解修饰，指定了事务的传播行为是 Propagation.REQUIRED，隔离级别是 Isolation.READ_COMMITTED，超时时间是 10 秒，并且事务不是只读的。

- 阅读更多 -

Spring面向切面编程（AOP）

System

2024-09-06

所有,java

Spring框架的AOP功能可以让你定义横切关注点，并将它们集中在一个点上。以下是一个简单的例子，展示了如何使用Spring AOP来记录方法的执行时间。

首先，添加Spring AOP的依赖到你的项目中（如果你使用的是Maven）：




<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

然后，创建一个切面类来定义横切逻辑：




import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
 
@Aspect
@Component
public class LoggingAspect {
 
    @Around("execution(* com.example.service.YourService.*(..))")
    public Object logServiceMethod(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        String methodName = methodSignature.getMethod().getName();
 
        // 打印方法开始执行的信息
        System.out.println("Method " + methodName + " starts");
 
        // 执行方法
        long start = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        long end = System.currentTimeMillis();
 
        // 打印方法执行的时间
        System.out.println("Method " + methodName + " takes " + (end - start) + "ms");
 
        return result;
    }
}

在上面的例子中，@Around注解指定了一个切点，它会围绕com.example.service.YourService类中所有方法的执行来应用这个切面。logServiceMethod方法会在被标记的方法执行前后打印信息。

确保你的Spring配置启用了组件扫描，以便Spring能够识别和注册这个切面：




@Configuration
@ComponentScan(basePackages = "com.example")
@EnableAspectJAutoProxy
public class AppConfig {
}

这样，每当YourService中的方法被调用时，都会执行LoggingAspect中定义的横切逻辑。

- 阅读更多 -

Django知识点总结

System

2024-09-06

所有,数据库

在Django中，一个常见的知识点是模型(Model)的创建和迁移(Migration)。以下是一个简单的例子：




# 在你的Django应用的models.py文件中
from django.db import models
 
class Person(models.Model):
    name = models.CharField(max_length=100)
    age = models.IntegerField()

接下来，你需要创建一个迁移文件来记录你对模型所做的更改。




python manage.py makemigrations your_app_name

这将创建一个迁移文件，其中包含了创建Person模型所需的所有SQL命令。

然后，你可以应用这些迁移来更新数据库。




python manage.py migrate your_app_name

这将根据迁移文件中的更改来更新数据库结构。

以上是一个简单的Django模型和迁移的例子。在实际应用中，你可能需要定义更复杂的模型关系，并多次重复迁移的过程。

System

2024-09-06

所有,java

报错问题："SpringBoot与MyBatisPlus整合常见‘XXXXMapper’ that could not be found问题处" 指的是在使用Spring Boot和MyBatis Plus进行开发时，系统无法找到对应的Mapper接口实例。

解释：

这个错误通常发生在MyBatis Plus无法扫描到Mapper接口时。可能的原因包括：

Mapper接口没有被放置在Spring Boot主程序可以扫描的包或子包下。
Mapper接口没有使用MyBatis Plus提供的@Mapper注解进行标注。
项目的配置文件中MyBatis Plus的路径配置不正确，导致扫描不到对应的Mapper接口。

解决方法：

确保Mapper接口包路径位于Spring Boot应用的@SpringBootApplication注解或@ComponentScan注解指定的扫描路径下。
在Mapper接口上添加@Mapper注解，或者在启动类上添加@MapperScan注解，指定需要扫描的Mapper接口的包路径。
检查application.properties或application.yml配置文件中关于MyBatis Plus的路径配置，确保路径正确无误。

示例：

如果你的Mapper接口位于com.example.mapper包下，确保你的启动类位于com.example或其子包中，或者在启动类上使用@ComponentScan(basePackages = "com.example")指定扫描路径，或者使用@MapperScan("com.example.mapper")指定Mapper接口的位置。

- 阅读更多 -

docker - compose 部署 Tomcat

System

2024-09-06

所有,java

以下是一个使用Docker Compose部署Tomcat的简单示例。首先，创建一个文件夹用于存放Docker Compose的配置文件和相关资源。然后，在该文件夹中创建一个名为docker-compose.yml的文件，并填写以下内容：




version: '3'
 
services:
  tomcat:
    image: tomcat:latest
    ports:
      - "8080:8080"
    volumes:
      - ./webapps:/usr/local/tomcat/webapps

这个配置文件定义了一个服务tomcat，使用最新版本的官方Tomcat Docker镜像，并将宿主机的8080端口映射到容器的8080端口，同时将宿主机的./webapps目录挂载到容器的/usr/local/tomcat/webapps目录中，以便可以部署和管理应用。

接下来，在同一目录下创建webapps文件夹，并将你的Web应用打包成WAR文件放置在该文件夹中。

最后，通过以下命令启动Tomcat容器：




docker-compose up

当你看到Tomcat服务启动并运行后，你可以通过浏览器访问http://localhost:8080来查看Tomcat服务器是否正确运行，并且你的应用是否已经部署成功。

- 阅读更多 -

基于spring boot+mybatisplus的后端开发

System

2024-09-06

所有,java

以下是一个基于Spring Boot和MyBatis-Plus的简单示例，展示了如何创建一个后端服务，该服务提供了一个简单的用户管理功能。

首先，在pom.xml中添加Spring Boot和MyBatis-Plus的依赖：




<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.x.x</version>
    </dependency>
    <!-- 数据库驱动依赖，以MySQL为例 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>

配置数据库和MyBatis-Plus：




spring:
  datasource:
    url: jdbc:mysql://localhost:3306/your_database?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
    username: your_username
    password: your_password
mybatis-plus:
  mapper-locations: classpath:/mappers/*.xml
  type-aliases-package: com.yourpackage.model

创建一个用户实体类：




import com.baomidou.mybatisplus.annotation.TableName;
 
@TableName("user")
public class User {
    private Long id;
    private String name;
    private Integer age;
    // 省略getter和setter
}

创建一个UserMapper接口：




import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 
public interface UserMapper extends BaseMapper<User> {
    // MyBatis-Plus会自动处理CRUD操作
}

创建一个服务类和对应的实现类：




public interface UserService {
    List<User> listUsers();
}
 
@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper userMapper;
 
    @Override
    public List<User> listUsers() {
        return userMapper.selectList(null);
    }
}

创建一个控制器类：




@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;
 
    @GetMapping
    public List<User> listUsers() {
        return userService.listUsers();
    }
}

启动类：




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

以上代码提供了一个简单的RESTful API，可以通过访问/users端点来获取用户列表。这只是一个基础示例，实际开发中可能需要根据具体需求进行扩展和定制。

- 阅读更多 -