要在Spring Boot中整合基于WSDL文件的WebService客户端与服务端，你可以使用Spring Web Services和JAX-WS。以下是整合的步骤和示例代码：

1. 添加依赖到你的pom.xml：

<!-- Spring WS -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web-services</artifactId>
</dependency>
<!-- JAX-WS -->
<dependency>
    <groupId>org.jvnet.jax-ws-commons.spring</groupId>
    <artifactId>jaxws-spring</artifactId>
    <version>1.9</version>
</dependency>

2. 使用wsimport工具根据WSDL生成客户端和服务端存根：

wsimport -keep -p com.example.client http://example.com/service?wsdl
wsimport -keep -p com.example.server http://example.com/service?wsdl

3. 配置客户端：

@Configuration
public class WebServiceClientConfig {
 
    @Bean
    public JaxWsPortProxyFactoryBean yourServiceClient() {
        JaxWsPortProxyFactoryBean proxy = new JaxWsPortProxyFactoryBean();
        proxy.setServiceName("YourServiceName");
        proxy.setPortName("YourPortName");
        proxy.setNamespaceUri("http://example.com/webservice");
        proxy.setServiceInterface(YourServiceInterface.class);
        proxy.setWsdlDocumentUrl("classpath:wsdl/YourService.wsdl");
        return proxy;
    }
}

4. 使用客户端：

@Autowired
private YourServiceInterface client;
 
public void callService() {
    client.yourWebServiceMethod();
}

5. 配置服务端：

@Configuration
public class WebServiceServerConfig {
 
    @Bean
    public SimpleJaxWsServiceExporter serviceExporter() {
        SimpleJaxWsServiceExporter exporter = new SimpleJaxWsServiceExporter();
        exporter.setBaseAddress("http://localhost:8080/ws");
        return exporter;
    }
}

6. 发布服务端：

@EndpointName("yourEndpoint")
public class YourServiceEndpoint {
 
    @Autowired
    private YourServiceInterface service;
 
    // Implement your web service methods
}

确保你的Spring Boot应用程序主类上有@EnableWs注解启用Web Services。

以上代码仅为示例，根据你的实际WSDL文件和服务接口，你需要调整配置和代码细节。

Spring 5 的 WebFlux 模块提供了对响应式编程的支持，这有助于构建可以在无阻塞的异步执行模式下运行的应用程序。WebFlux 使用 Project Reactor 库来实现响应式流。

以下是一个简单的 Spring WebFlux 应用程序的例子：

1. 创建一个新的 Spring Boot 项目，并添加 WebFlux 依赖。

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

2. 创建一个简单的路由器。

@Configuration
public class RouterConfig {
 
    @Bean
    public RouterFunction<ServerResponse> monoRouterFunction(EmployeeHandler employeeHandler) {
        return route(GET("/employees/{id}"), employeeHandler::getEmployee)
              .andRoute(GET("/employees"), employeeHandler::listEmployees);
    }
}

3. 创建处理请求的处理器。

@Component
public class EmployeeHandler {
 
    public Mono<ServerResponse> getEmployee(ServerRequest request) {
        int id = Integer.parseInt(request.pathVariable("id"));
        return ServerResponse.ok().body(fromObject(new Employee(id, "Name " + id)));
    }
 
    public Mono<ServerResponse> listEmployees(ServerRequest request) {
        Flux<Employee> employees = Flux.range(1, 10).map(id -> new Employee(id, "Name " + id));
        return ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(employees, Employee.class);
    }
}

4. 创建一个简单的 Employee 实体类。

public class Employee {
    private int id;
    private String name;
 
    // Constructors, getters and setters
}

这个例子展示了如何使用 Spring WebFlux 创建一个简单的响应式 REST API。这种非阻塞的方法对于构建可扩展和高性能的服务非常有用。

基于提供的信息，我们无法提供一个完整的解决方案，因为这涉及到开发一个完整的校园二手交易平台。但是，我可以提供一个简化版的Spring Boot后端服务的框架代码示例，这个框架可以作为开发校园二手交易小程序的基础。

// 引入Spring Boot相关依赖
import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.*;
import org.springframework.web.bind.annotation.*;
 
@RestController
@EnableAutoConfiguration
public class ExampleController {
 
    // 返回二手商品列表
    @GetMapping("/second-hand-items")
    public List<SecondHandItem> getSecondHandItems() {
        // 模拟数据库查询
        return Arrays.asList(new SecondHandItem("笔记本电脑", "二手", "学长", "图片链接"));
    }
 
    // 发布二手商品
    @PostMapping("/second-hand-items")
    public SecondHandItem postSecondHandItem(@RequestBody SecondHandItem item) {
        // 模拟保存到数据库
        return item;
    }
 
    public static class SecondHandItem {
        private String name;
        private String condition;
        private String seller;
        private String imageUrl;
 
        // 构造函数、getter和setter省略
    }
 
    public static void main(String[] args) {
        SpringApplication.run(ExampleController.class, args);
    }
}

这个简单的Spring Boot应用程序定义了一个REST API，可以用来获取和发布二手商品信息。在实际应用中，你需要连接数据库，实现用户认证，处理支付等功能。这只是一个开始，你需要根据自己的需求进一步开发。

由于篇幅所限，我将提供一个简化的Spring Boot项目的核心配置类示例。这个示例展示了如何配置Spring Boot项目以及如何创建一个简单的REST控制器。

package com.example.demo;
 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
 
@SpringBootApplication
public class DemoApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}
 
@RestController
class HelloController {
 
    @GetMapping("/hello")
    public String hello() {
        return "Hello, World!";
    }
}

这个代码实例创建了一个简单的Spring Boot应用程序，包括一个REST控制器，它响应对/hello端点的GET请求。当运行这个应用程序时，访问http://localhost:8080/hello将返回Hello, World!。这个示例提供了一个基本框架，可以在此基础上根据实际需求添加更多功能。

在Spring Boot中动态加载Jar包可以通过URLClassLoader来实现。以下是一个简化的例子，展示了如何在运行时加载Jar文件并创建其中定义的Bean。

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.file.Paths;
 
public class DynamicJarLoadingExample {
 
    public static void main(String[] args) throws Exception {
        // 假设这是你的Jar文件路径
        String jarFilePath = "path/to/your/jarfile.jar";
 
        // 加载Jar文件
        URL jarUrl = new URL(Paths.get(jarFilePath).toUri().toURL().toString());
        try (URLClassLoader loader = new URLClassLoader(new URL[]{jarUrl})) {
            // 假设你的Jar包中有一个配置类，我们称之为MyJarConfig
            Class<?> configClass = loader.loadClass("com.example.MyJarConfig");
 
            // 创建Spring应用上下文
            ApplicationContext context = new AnnotationConfigApplicationContext(configClass);
 
            // 现在你可以从context中获取Bean了
            // ...
        }
    }
}

在这个例子中，我们首先定义了Jar文件的路径，并使用URLClassLoader来加载这个Jar文件。然后，我们通过loadClass加载Jar包中的配置类（假设配置类继承自@Configuration）。最后，我们使用AnnotationConfigApplicationContext来创建一个新的Spring应用上下文，并可以从中获取Jar包中定义的Bean。

请注意，你需要确保Jar文件中的配置类可以被URLClassLoader加载，并且类名和包路径是正确的。此外，由于动态加载了代码和类，因此可能会有安全风险，需要确保Jar文件的来源是可信的。

要实现一个基于Spring Boot的学生选课系统，你需要定义系统的各个模块，包括用户管理、课程管理、选课功能等。以下是一个简化的例子，展示了如何使用Spring Boot创建一个简单的选课系统。

1. 创建Maven项目并添加Spring Boot依赖。
2. 定义实体类（如Student, Course, Enrollment）。
3. 创建相应的Repository接口。
4. 创建Service层处理业务逻辑。
5. 创建Controller层处理HTTP请求。
6. 配置Spring Boot应用并运行。

以下是一个非常简单的例子，仅包含基础代码框架，不包含具体业务逻辑和数据库操作。

// Student.java
public class Student {
    private Long id;
    private String name;
    // getters and setters
}
 
// Course.java
public class Course {
    private Long id;
    private String name;
    // getters and setters
}
 
// Enrollment.java
public class Enrollment {
    private Long id;
    private Student student;
    private Course course;
    // getters and setters
}
 
// StudentRepository.java
public interface StudentRepository {
    // 定义操作Student的方法
}
 
// CourseRepository.java
public interface CourseRepository {
    // 定义操作Course的方法
}
 
// EnrollmentService.java
@Service
public class EnrollmentService {
    // 定义选课的业务逻辑方法
}
 
// EnrollmentController.java
@RestController
@RequestMapping("/enrollments")
public class EnrollmentController {
 
    @Autowired
    private EnrollmentService enrollmentService;
 
    @PostMapping
    public ResponseEntity<?> enroll(@RequestBody Enrollment enrollment) {
        // 调用服务层方法处理选课
        return ResponseEntity.ok().build();
    }
 
    @GetMapping("/{studentId}")
    public ResponseEntity<?> getEnrolledCourses(@PathVariable("studentId") Long studentId) {
        // 获取学生已选课程
        return ResponseEntity.ok().build();
    }
}
 
// Application.java
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

在实际应用中，你需要实现具体的数据库操作、业务逻辑和安全控制。这只是一个简单的框架，提供了如何开始构建学生选课系统的基础。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.crypto.password.NoOpPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
 
@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
 
    @Bean
    public UserDetailsService userDetailsService() {
        InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();
        manager.createUser(User.withUsername("user").password("password").roles("USER").build());
        manager.createUser(User.withUsername("admin").password("password").roles("USER", "ADMIN").build());
        return manager;
    }
 
    @Bean
    public PasswordEncoder passwordEncoder() {
        return NoOpPasswordEncoder.getInstance(); // 仅用于开发环境，生产环境应使用更安全的密码编码器
    }
 
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService()).passwordEncoder(passwordEncoder());
    }
 
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/", "/home").permitAll()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
                .and()
            .logout()
                .permitAll();
    }
}

这段代码定义了一个简单的安全配置，它创建了一个用户详情服务，并在认证管理器中使用了它。同时，它配置了HTTP安全，允许一些路径公开访问，需要认证才能访问其他路径

由于提供的信息不足以完整回答这个问题，我将给出一个简化版的MyBatis使用指南。

1. 配置文件：

在mybatis-config.xml中配置数据库连接信息和MyBatis运行环境。

<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/myapp"/>
                <property name="username" value="root"/>
                <property name="password" value="password"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="org/myapp/Mapper.xml"/>
    </mappers>
</configuration>

2. Mapper XML文件：

定义SQL映射。

<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.myapp.Mapper">
    <select id="selectUsers" resultType="org.myapp.User">
        SELECT * FROM users
    </select>
    <insert id="insertUser" parameterType="org.myapp.User">
        INSERT INTO users(name, email) VALUES (#{name}, #{email})
    </insert>
</mapper>

3. Java代码：

使用MyBatis API执行SQL语句。

// 获取SqlSessionFactory
String resource = "org/myapp/mybatis-config.xml";
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resource);
 
// 获取SqlSession
try (SqlSession session = sqlSessionFactory.openSession()) {
    // 获取Mapper接口
    org.myapp.Mapper mapper = session.getMapper(org.myapp.Mapper.class);
    
    // 执行SQL语句
    List<User> users = mapper.selectUsers();
    User newUser = new User("John Doe", "john@example.com");
    mapper.insertUser(newUser);
    
    // 提交事务
    session.commit();
}

注意：

• 需要替换org.myapp为你的实际包名。
• 需要替换User类为你的实际实体类。
• 需要引入MyBatis依赖。

以上是一个简化的MyBatis使用指南，实际应用中还需要处理更多细节，如事务管理、异常处理等。

在JavaWeb的第四章中，我们主要讨论了Servlet和Tomcat服务器的基础知识。在这一章中，我们将使用Servlet和Tomcat来创建一个简单的HTTP服务器。

我们将创建一个简单的Servlet，它将响应所有的HTTP GET请求。

解决方案1：

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>");
    }
}

在上述代码中，我们创建了一个名为HelloWorldServlet的类，该类扩展了HttpServlet类。我们覆盖了doGet方法，该方法响应所有的HTTP GET请求。

解决方案2：

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>");
        out.println("<head>");
        out.println("<title>Hello World</title>");
        out.println("</head>");
        out.println("<body>");
        out.println("<h1>Hello World</h1>");
        out.println("</body>");
        out.println("</html>");
    }
}

在这个解决方案中，我们使用PrintWriter对象的println方法来生成HTML代码。这样做的好处是代码更易读，更易于维护。

然后，我们需要在web.xml文件中注册我们的Servlet。

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

在上述的web.xml代码中，我们注册了一个名为HelloWorldServlet的Servlet，并将其映射到URL模式/hello。

最后，我们需要将我们的Servlet编译成class文件，并将其放在我们的web应用程序的WEB-INF/classes目录下，或者打包成jar文件，并将其放在WEB-INF/lib目录下。

然后，我们可以启动Tomcat服务器，并通过浏览器访问我们的Servlet，例如：http://localhost:8080/hello。

注意：在实际的JavaWeb开发中，我们通常会使用像Maven或Gradle这样的构建工具来管理我们的项目依赖，编译代码，并将我们的应用程序打包成war文件，然后部署到Tomcat服务器中。

在Spring框架中，事务管理是一个核心组件，它确保数据库操作的一致性和完整性。如果事务失效，可能有以下几个原因：

1. 方法没有被声明为@Transactional。
2. 方法不是public的。
3. 事务方法被非代理对象（非容器管理的bean）调用。
4. 数据库本身不支持事务。
5. 事务方法内部调用了异常不被检查的方法。
6. 异常类型不被事务管理配置所考虑。

解决方法：

1. 确保方法用@Transactional注解。
2. 确保方法是public。
3. 确保事务方法是由Spring管理的代理对象调用。
4. 确保数据库支持事务。
5. 如果方法内部调用了另一个事务方法，请确保被调用方法也被@Transactional注解。
6. 检查@Transactional注解中的rollbackFor属性，确保它包含可以触发回滚的异常类型。

示例代码：

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
@Service
public class MyService {
 
    @Transactional(rollbackFor = Exception.class)
    public void someTransactionalMethod() {
        // 数据库操作
    }
}

确保事务方法被Spring管理的代理调用：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Service;
 
@Service
public class AnotherService {
 
    @Autowired
    private ApplicationContext context;
 
    public void callTransactionalMethod() {
        MyService myService = context.getBean(MyService.class);
        myService.someTransactionalMethod();
    }
}

以上示例展示了如何声明事务，确保其可见性，以及如何确保通过Spring管理的代理来调用事务方法。