MAVEN 导入 

<dependency>
    <groupId>javax.sip</groupId>
    <artifactId>jain-sip-api</artifactId>
    <version>1.2.1.4</version>
</dependency>
<!-- https://mvnrepository.com/artifact/javax.sip/jain-sip-ri -->
<dependency>
    <groupId>javax.sip</groupId>
    <artifactId>jain-sip-ri</artifactId>
    <version>1.2.344</version>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>
<dependency>
    <groupId>javax.sip</groupId>
    <artifactId>jain-sip-ri</artifactId>
    <version>1.3.0-91</version>
</dependency>

JAVA 类 代码

package MyTestClass;

import javax.sip.*;
import javax.sip.address.Address;
import javax.sip.address.AddressFactory;
import javax.sip.address.SipURI;
import javax.sip.header.*;
import javax.sip.message.MessageFactory;
import javax.sip.message.Request;
import javax.sip.message.Response;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

public class MySipTest {
    public static void main(String[] args) {
        String username = "local";
        String ip = "192.168.0.92";
        int port = 5060;

        try {
            Properties prop = new Properties();
            prop.setProperty("javax.sip.STACK_NAME", "100");
            prop.setProperty("javax.sip.IP_ADDRESS", ip);
            prop.setProperty("javax.sip.OUTBOUND_PROXY", ip + ":" + port + "/udp");
            prop.setProperty("javax.sip.HEADER_EXTENSIONS", "Supported");

            SipFactory sipFactory = SipFactory.getInstance();
            //sipFactory.setPathName("gov.nist");

            SipStack sipStack = sipFactory.createSipStack(prop);
            HeaderFactory headerFactory = sipFactory.createHeaderFactory();
            AddressFactory addressFactory = sipFactory.createAddressFactory();
            MessageFactory messageFactory = sipFactory.createMessageFactory();
            ListeningPoint listeningPoint_udp = sipStack.createListeningPoint(5061, "udp");
            SipProvider sipProvider = sipStack.createSipProvider(listeningPoint_udp);
            ClientListener listener = new ClientListener(addressFactory, headerFactory, messageFactory, sipProvider);
            sipProvider.addSipListener(listener);
            //requestURI
            SipURI requestSipURI = addressFactory.createSipURI(username, ip + ":" + port);
            requestSipURI.setTransportParam("udp");
            SipURI localUrl = addressFactory.createSipURI(username, ip + ":" + port);
            SipURI serverUrl = addressFactory.createSipURI(username, ip + ":" + port);
            //from
            FromHeader fromHeader = headerFactory.createFromHeader(addressFactory.createAddress(localUrl), "caller");
            //to
            ToHeader toHeader = headerFactory.createToHeader(addressFactory.createAddress(serverUrl), null);
            //via
            ViaHeader viaHeader = headerFactory.createViaHeader(ip, port, "udp", "branchingbranching");
            //List
            List<ViaHeader> viaHeaderList = new ArrayList<ViaHeader>();
            viaHeaderList.add(viaHeader);
            //callid,cseq,maxforwards
            CallIdHeader callIdHeader = sipProvider.getNewCallId();
            CSeqHeader cSeqHeader = headerFactory.createCSeqHeader(1L, Request.INVITE);
            MaxForwardsHeader maxForwardsHeader = headerFactory.createMaxForwardsHeader(70);
            Request request = messageFactory.createRequest(requestSipURI, Request.INVITE, callIdHeader, cSeqHeader,
                    fromHeader, toHeader, viaHeaderList, maxForwardsHeader);
            //contact
            SipURI contactURI = addressFactory.createSipURI("100", ip + ":" + port);
            contactURI.setPort(port);
            Address contactAddress = addressFactory.createAddress(contactURI);
            contactAddress.setDisplayName("100");
            ContactHeader contactHeader = headerFactory.createContactHeader(contactAddress);
            request.addHeader(contactHeader);
            // expires
            ExpiresHeader expiresHeader = headerFactory.createExpiresHeader(3600);
            request.addHeader(expiresHeader);
            sipProvider.sendRequest(request);
        } catch (Exception ex) {
            System.out.println(ex);
        }


    }
}
class ClientListener implements SipListener {
    private AddressFactory addressFactory;

    private HeaderFactory headerFactory;

    private MessageFactory messageFactory;

    private SipProvider sipProvider;

    public ClientListener(AddressFactory addressFactory, HeaderFactory headerFactory, MessageFactory messageFactory,
                          SipProvider sipProvider) {
        super();
        this.addressFactory = addressFactory;
        this.headerFactory = headerFactory;
        this.messageFactory = messageFactory;
        this.sipProvider = sipProvider;
    }

    @Override
    public void processRequest(RequestEvent requestEvent) {
        System.out.println("processRequest执行");
        Request request = requestEvent.getRequest();
        if(null == request) {
            System.out.println("requestEvent.getRequest() is null.");
            return ;
        }

        System.out.println("request内容是\n"+request);
    }

    @Override
    public void processResponse(ResponseEvent responseEvent) {
        System.out.println("processResponse执行");
        Response response = responseEvent.getResponse();
        if(null == response) {
            System.out.println("response is null.");
            return ;
        }
        System.out.println("返回码:"+response.getStatusCode());
        System.out.println("返回的数据 :"+response);
    }

    @Override
    public void processTimeout(TimeoutEvent timeoutEvent) {

    }

    @Override
    public void processIOException(IOExceptionEvent ioExceptionEvent) {

    }

    @Override
    public void processTransactionTerminated(TransactionTerminatedEvent transactionTerminatedEvent) {
        System.out.println("processTransactionTerminated执行");
    }

    @Override
    public void processDialogTerminated(DialogTerminatedEvent dialogTerminatedEvent) {
        System.out.println("processDialogTerminated执行");
    }
}